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

Text item : reduce a lot of code for several text item

Browse Source 
git-svn-id: svn+ssh://svn.tuxfamily.org/svnroot/qet/qet/trunk@3379 bfdf4180-ca20-0410-9c96-a3a8aa849046
This commit is contained in:
blacksun 2014-10-17 21:30:42 +00:00
parent 7f4d2cc317
commit 243cd16e72
16 changed files with 158 additions and 547 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

32
sources/diagram.cpp
View File

@ -26,7 +26,6 @@
#include "diagramposition.h"
#include "qetgraphicsitem/elementtextitem.h"
#include "elementsmover.h"
#include "elementtextsmover.h"
#include "exportdialog.h"
#include "qetgraphicsitem/ghostelement.h"
#include "qetgraphicsitem/independenttextitem.h"
@ -68,7 +67,6 @@ Diagram::Diagram(QObject *parent) :
// initialise les objets gerant les deplacements
elements_mover_ = new ElementsMover(); // deplacements d'elements/conducteurs/textes
element_texts_mover_ = new ElementTextsMover(); // deplacements d'ElementTextItem
connect(
&border_and_titleblock, SIGNAL(needTitleBlockTemplate(const QString &)),
@ -94,7 +92,6 @@ Diagram::~Diagram() {
// delete of object for manage movement
delete elements_mover_;
delete element_texts_mover_;
// list removable items
QList<QGraphicsItem *> deletable_items;
@ -1020,33 +1017,6 @@ void Diagram::endMoveElements() {
elements_mover_ -> endMovement();
}
/**
Initialise un deplacement d'ElementTextItems
@param driver_item Item deplace par la souris et ne necessitant donc pas
d'etre deplace lors des appels a continueMovement.
@see ElementTextsMover
*/
int Diagram::beginMoveElementTexts(QGraphicsItem *driver_item) {
return(element_texts_mover_ -> beginMovement(this, driver_item));
}
/**
Prend en compte un mouvement composant un deplacement d'ElementTextItems
@param movement mouvement a ajouter au deplacement en cours
@see ElementTextsMover
*/
void Diagram::continueMoveElementTexts(const QPointF &movement) {
element_texts_mover_ -> continueMovement(movement);
}
/**
Finalise un deplacement d'ElementTextItems
@see ElementTextsMover
*/
void Diagram::endMoveElementTexts() {
element_texts_mover_ -> endMovement();
}
/**
Permet de savoir si un element est utilise sur un schema
@param location Emplacement d'un element
@ -1299,6 +1269,8 @@ DiagramContent Diagram::selectedContent() {
dc.elements << elmt;
} else if (IndependentTextItem *iti = qgraphicsitem_cast<IndependentTextItem *>(item)) {
dc.textFields << iti;
} else if (ElementTextItem *eti = qgraphicsitem_cast<ElementTextItem *>(item)) {
dc.elementTextFields << eti;
} else if (Conductor *c = qgraphicsitem_cast<Conductor *>(item)) {
// recupere les conducteurs selectionnes isoles (= non deplacables mais supprimables)
if (

5
sources/diagram.h
View File

@ -37,7 +37,6 @@ class Element;
class ElementsLocation;
class ElementsMover;
class ElementTextItem;
class ElementTextsMover;
class IndependentTextItem;
class QETProject;
class Terminal;
@ -85,7 +84,6 @@ class Diagram : public QGraphicsScene {
private:
QGraphicsLineItem *conductor_setter_;
ElementsMover *elements_mover_;
ElementTextsMover *element_texts_mover_;
QGIManager *qgi_manager_;
QETProject *project_;
@ -191,9 +189,6 @@ class Diagram : public QGraphicsScene {
int beginMoveElements(QGraphicsItem * = 0);
void continueMoveElements(const QPointF &);
void endMoveElements();
int beginMoveElementTexts(QGraphicsItem * = 0);
void continueMoveElementTexts(const QPointF &);
void endMoveElementTexts();
bool usesElement(const ElementsLocation &);
bool usesTitleBlockTemplate(const QString &);

68
sources/diagramcommands.cpp
View File

@ -329,7 +329,13 @@ void MoveElementsCommand::move(const QPointF &actual_movement) {
typedef DiagramContent dc;
//Move every movable item, except conductor
foreach (QGraphicsItem *qgi, content_to_move.items(dc::Elements | dc::TextFields | dc::Images | dc::Shapes)) {
foreach (QGraphicsItem *qgi, content_to_move.items(dc::Elements | dc::TextFields | dc::ElementTextFields | dc::Images | dc::Shapes)) {
//If curent item have parent, and parent item is in content_to_move
//we don't apply movement to this item, because this item will be moved by is parent.
if (qgi->parentItem()) {
if (content_to_move.items().contains(qgi->parentItem()))
continue;
}
if(qgi->toGraphicsObject()) {
setupAnimation(qgi->toGraphicsObject(), "pos", qgi->pos(), qgi->pos() + actual_movement);
}
@ -382,66 +388,6 @@ void MoveElementsCommand::setupAnimation(QObject *target, const QByteArray &prop
m_anim_group->addAnimation(animation);
}
/**
Constructeur
@param diagram Schema sur lequel on deplace des champs de texte
@param texts Liste des textes deplaces
@param m translation subie par les elements
@param parent QUndoCommand parent
*/
MoveElementsTextsCommand::MoveElementsTextsCommand(
Diagram *diagram,
const QSet<ElementTextItem *> &texts,
const QPointF &m,
QUndoCommand *parent
) :
QUndoCommand(parent),
diagram(diagram),
texts_to_move(texts),
movement(m),
first_redo(true)
{
QString moved_content_sentence = QET::ElementsAndConductorsSentence(0, 0, texts_to_move.count());
setText(
QString(
QObject::tr(
"d\351placer %1",
"undo caption - %1 is a sentence listing the moved content"
).arg(moved_content_sentence)
)
);
}
/// Destructeur
MoveElementsTextsCommand::~MoveElementsTextsCommand() {
}
/// annule le deplacement
void MoveElementsTextsCommand::undo() {
diagram -> showMe();
move(-movement);
}
/// refait le deplacement
void MoveElementsTextsCommand::redo() {
diagram -> showMe();
if (first_redo) first_redo = false;
else move(movement);
}
/**
deplace les elements et conducteurs
@param actual_movement translation a effectuer sur les elements et conducteurs
*/
void MoveElementsTextsCommand::move(const QPointF &actual_movement) {
// deplace les textes
foreach(ElementTextItem *text, texts_to_move) {
QPointF applied_movement = text -> mapMovementToParent(text -> mapMovementFromScene(actual_movement));
text -> setPos(text -> pos() + applied_movement);
}
}
/**
Constructeur
@param diagram Schema sur lequel on deplace des champs de texte

29
sources/diagramcommands.h
View File

@ -185,35 +185,6 @@ class MoveElementsCommand : public QUndoCommand {
bool first_redo;
};
/**
This command moves text items related to elements on a particular diagram.
*/
class MoveElementsTextsCommand : public QUndoCommand {
// constructors, destructor
public:
MoveElementsTextsCommand(Diagram *, const QSet<ElementTextItem *> &, const QPointF &m, QUndoCommand * = 0);
virtual ~MoveElementsTextsCommand();
private:
MoveElementsTextsCommand(const MoveElementsTextsCommand &);
// methods
public:
virtual void undo();
virtual void redo();
virtual void move(const QPointF &);
// attributes
private:
/// diagram the movement takes place on.
Diagram *diagram;
/// text items to be moved
QSet<ElementTextItem *> texts_to_move;
/// applied movement
QPointF movement;
/// prevent the first call to redo()
bool first_redo;
};
/**
This command moves text items related to conductors on a particular
diagram.

27
sources/diagramcontent.cpp
View File

@ -17,10 +17,12 @@
*/
#include "diagramcontent.h"
#include <QGraphicsItem>
#include "qetgraphicsitem/element.h"
#include "qetgraphicsitem/independenttextitem.h"
#include "qetgraphicsitem/conductor.h"
#include "qetgraphicsitem/diagramimageitem.h"
#include "element.h"
#include "independenttextitem.h"
#include "conductor.h"
#include "diagramimageitem.h"
#include "elementtextitem.h"
#include "qetshapeitem.h"
/**
Constructeur par defaut. Ne contient rien.
@ -34,6 +36,7 @@ DiagramContent::DiagramContent() {
DiagramContent::DiagramContent(const DiagramContent &other) :
elements(other.elements),
textFields(other.textFields),
elementTextFields(other.elementTextFields),
images(other.images),
shapes(other.shapes),
conductorsToUpdate(other.conductorsToUpdate),
@ -71,6 +74,7 @@ QList<Conductor *> DiagramContent::conductors(int filter) const {
void DiagramContent::clear() {
elements.clear();
textFields.clear();
elementTextFields.clear();
images.clear();
shapes.clear();
conductorsToUpdate.clear();
@ -85,10 +89,13 @@ void DiagramContent::clear() {
QList<QGraphicsItem *> DiagramContent::items(int filter) const {
QList<QGraphicsItem *> items_list;
foreach(QGraphicsItem *qgi, conductors(filter)) items_list << qgi;
if (filter & Elements) foreach(QGraphicsItem *qgi, elements) items_list << qgi;
if (filter & TextFields) foreach(QGraphicsItem *qgi, textFields) items_list << qgi;
if (filter & Images) foreach(QGraphicsItem *qgi, images) items_list << qgi;
if (filter & Shapes) foreach(QGraphicsItem *qgi, shapes) items_list << qgi;
if (filter & Elements) foreach(QGraphicsItem *qgi, elements) items_list << qgi;
if (filter & TextFields) foreach(QGraphicsItem *qgi, textFields) items_list << qgi;
if (filter & ElementTextFields) foreach(QGraphicsItem *qgi, elementTextFields) items_list << qgi;
if (filter & Images) foreach(QGraphicsItem *qgi, images) items_list << qgi;
if (filter & Shapes) foreach(QGraphicsItem *qgi, shapes) items_list << qgi;
if (filter & SelectedOnly) {
foreach(QGraphicsItem *qgi, items_list) {
if (!qgi -> isSelected()) items_list.removeOne(qgi);
@ -106,6 +113,7 @@ int DiagramContent::count(int filter) const {
if (filter & SelectedOnly) {
if (filter & Elements) foreach(Element *element, elements) { if (element -> isSelected()) ++ count; }
if (filter & TextFields) foreach(DiagramTextItem *dti, textFields) { if (dti -> isSelected()) ++ count; }
if (filter & ElementTextFields) foreach(DiagramTextItem *dti, elementTextFields) { if (dti -> isSelected()) ++ count; }
if (filter & Images) foreach(DiagramImageItem *dii, images) { if (dii -> isSelected()) ++ count; }
if (filter & Shapes) foreach(QetShapeItem *dsi, shapes) { if (dsi -> isSelected()) ++ count; }
if (filter & ConductorsToMove) foreach(Conductor *conductor, conductorsToMove) { if (conductor -> isSelected()) ++ count; }
@ -115,6 +123,7 @@ int DiagramContent::count(int filter) const {
else {
if (filter & Elements) count += elements.count();
if (filter & TextFields) count += textFields.count();
if (filter & ElementTextFields) count += elementTextFields.count();
if (filter & Images) count += images.count();
if (filter & Shapes) count += shapes.count();
if (filter & ConductorsToMove) count += conductorsToMove.count();
@ -133,7 +142,7 @@ int DiagramContent::count(int filter) const {
QString DiagramContent::sentence(int filter) const {
int elements_count = (filter & Elements) ? elements.count() : 0;
int conductors_count = conductors(filter).count();
int textfields_count = (filter & TextFields) ? textFields.count() : 0;
int textfields_count = (filter & TextFields) ? (textFields.count() + elementTextFields.count()) : 0;
int images_count = (filter & Images) ? images.count() : 0;
int shapes_count = (filter & Shapes) ? shapes.count() : 0;

27
sources/diagramcontent.h
View File

@ -17,12 +17,16 @@
*/
#ifndef DIAGRAM_CONTENT_H
#define DIAGRAM_CONTENT_H
#include <QtGui>
#include "qetgraphicsitem/qetshapeitem.h"
#include <QSet>
class QGraphicsItem;
class Conductor;
class Element;
class IndependentTextItem;
class DiagramImageItem;
class ElementTextItem;
class QetShapeItem;
/**
This class provides a container that makes the transmission of diagram content
@ -43,20 +47,23 @@ class DiagramContent {
enum Filter {
Elements = 1,
TextFields = 2,
Images = 4,
ConductorsToMove = 8,
ConductorsToUpdate = 16,
OtherConductors = 32,
AnyConductor = 56,
Shapes = 64,
All = 127,
SelectedOnly = 128
ElementTextFields = 4,
Images = 8,
ConductorsToMove = 16,
ConductorsToUpdate = 32,
OtherConductors = 64,
AnyConductor = 112,
Shapes = 128,
All = 255,
SelectedOnly = 256
};
/// Hold electrical elements
QSet<Element *> elements;
/// Hold independent text items
QSet<IndependentTextItem *> textFields;
/// Hold element text item
QSet <ElementTextItem *> elementTextFields;
/// Hold image
QSet<DiagramImageItem *> images;
/// Hold shape

22
sources/elementsmover.cpp
View File

@ -16,13 +16,14 @@
along with QElectroTech. If not, see <http://www.gnu.org/licenses/>.
*/
#include "elementsmover.h"
#include "qetgraphicsitem/conductor.h"
#include "qetgraphicsitem/conductortextitem.h"
#include "conductor.h"
#include "conductortextitem.h"
#include "diagram.h"
#include "diagramcommands.h"
#include "qetgraphicsitem/element.h"
#include "qetgraphicsitem/independenttextitem.h"
#include "qetgraphicsitem/diagramimageitem.h"
#include "element.h"
#include "independenttextitem.h"
#include "diagramimageitem.h"
#include "elementtextitem.h"
/**
* @brief ElementsMover::ElementsMover Constructor
@ -74,6 +75,11 @@ int ElementsMover::beginMovement(Diagram *diagram, QGraphicsItem *driver_item) {
current_movement_ = QPointF(0.0, 0.0);
moved_content_ = diagram -> selectedContent();
if (driver_item -> parentItem()) {
if (moved_content_.items().contains(driver_item -> parentItem()))
moved_content_.clear();
}
/* We need to save the position of conductor text (ConductorTextItem)
* if the position is defined by user
@ -110,8 +116,12 @@ void ElementsMover::continueMovement(const QPointF &movement) {
//Move every movable item, except conductor
typedef DiagramContent dc;
foreach (QGraphicsItem *qgi, moved_content_.items(dc::Elements | dc::TextFields | dc::Images | dc::Shapes)) {
foreach (QGraphicsItem *qgi, moved_content_.items(dc::Elements | dc::TextFields | dc::ElementTextFields | dc::Images | dc::Shapes)) {
if (qgi == movement_driver_) continue;
if (qgi->parentItem()) {
if (moved_content_.items().contains(qgi->parentItem()))
continue;
}
qgi -> setPos(qgi->pos() + movement);
}

4
sources/elementsmover.h
View File

@ -17,8 +17,10 @@
*/
#ifndef ELEMENTS_MOVER_H
#define ELEMENTS_MOVER_H
#include <QtGui>
#include <QPointF>
#include "diagramcontent.h"
class ConductorTextItem;
class Diagram;
/**

141
sources/elementtextsmover.cpp
View File

@ -1,141 +0,0 @@
/*
Copyright 2006-2014 The QElectroTech Team
This file is part of QElectroTech.
QElectroTech is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 2 of the License, or
(at your option) any later version.
QElectroTech is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with QElectroTech. If not, see <http://www.gnu.org/licenses/>.
*/
#include "elementtextsmover.h"
#include "qetgraphicsitem/conductor.h"
#include "qetgraphicsitem/elementtextitem.h"
#include "diagram.h"
#include "diagramcommands.h"
#include "qetgraphicsitem/element.h"
#include "qetgraphicsitem/independenttextitem.h"
/**
Constructeur
*/
ElementTextsMover::ElementTextsMover() :
movement_running_(false),
current_movement_(),
diagram_(0),
movement_driver_(0),
moved_texts_()
{
}
/**
Destructeur
*/
ElementTextsMover::~ElementTextsMover() {
}
/**
@return true si ce gestionnaire de deplacement est pret a etre utilise,
false sinon. Un gestionnaire de deplacement est pret a etre utilise a partir
du moment ou le mouvement precedemment gere n'est plus en cours.
*/
bool ElementTextsMover::isReady() const {
return(!movement_running_);
}
/**
Demarre un nouveau mouvement d'ElementTextItems
@param diagram Schema sur lequel se deroule le deplacement
@param driver_item Item deplace par la souris et ne necessitant donc pas
d'etre deplace lors des appels a continueMovement.
@return le nombre d'items concernes par le deplacement, ou -1 si le
mouvement n'a pas ete initie
*/
int ElementTextsMover::beginMovement(Diagram *diagram, QGraphicsItem *driver_item) {
// il ne doit pas y avoir de mouvement en cours
if (movement_running_) return(-1);
// on s'assure que l'on dispose d'un schema pour travailler
if (!diagram) return(-1);
diagram_ = diagram;
// on prend en compte le driver_item
movement_driver_ = driver_item;
// au debut du mouvement, le deplacement est nul
current_movement_ = QPointF(0.0, 0.0);
// on stocke dans cet objet les items concernes par le deplacement
moved_texts_.clear();
foreach(QGraphicsItem *item, diagram -> selectedItems()) {
if (ElementTextItem *text_item = qgraphicsitem_cast<ElementTextItem *>(item)) {
moved_texts_ << text_item;
}
}
// on s'assure qu'il y a quelque chose a deplacer
if (!moved_texts_.count()) return(-1);
// a ce stade, on dispose de toutes les informations necessaires pour
// prendre en compte les mouvements
// il y a desormais un mouvement en cours
movement_running_ = true;
return(moved_texts_.count());
}
/**
Ajoute un mouvement au deplacement en cours. Cette methode
@param movement mouvement a ajouter au deplacement en cours
*/
void ElementTextsMover::continueMovement(const QPointF &movement) {
// un mouvement doit avoir ete initie
if (!movement_running_) return;
// inutile de faire quoi que ce soit s'il n'y a pas eu de mouvement concret
if (movement.isNull()) return;
// prise en compte du mouvement
current_movement_ += movement;
// deplace les elements selectionnes
foreach(ElementTextItem *text_item, moved_texts_) {
if (movement_driver_ && text_item == movement_driver_) continue;
QPointF applied_movement = text_item -> mapMovementToParent(text_item-> mapMovementFromScene(movement));
text_item -> setPos(text_item -> pos() + applied_movement);
}
}
/**
Termine le deplacement en creant un objet d'annulation et en l'ajoutant a
la QUndoStack du schema concerne.
@see Diagram::undoStack()
*/
void ElementTextsMover::endMovement() {
// un mouvement doit avoir ete initie
if (!movement_running_) return;
// inutile de faire quoi que ce soit s'il n'y a pas eu de mouvement concret
if (!current_movement_.isNull()) {
// cree un objet d'annulation pour le mouvement ainsi realise
MoveElementsTextsCommand*undo_object = new MoveElementsTextsCommand(
diagram_,
moved_texts_,
current_movement_
);
diagram_ -> undoStack().push(undo_object);
}
// il n'y a plus de mouvement en cours
movement_running_ = false;
}

51
sources/elementtextsmover.h
View File

@ -1,51 +0,0 @@
/*
Copyright 2006-2014 The QElectroTech Team
This file is part of QElectroTech.
QElectroTech is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 2 of the License, or
(at your option) any later version.
QElectroTech is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with QElectroTech. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef ELEMENT_TEXTS_MOVER_H
#define ELEMENT_TEXTS_MOVER_H
#include <QtGui>
#include "diagramcontent.h"
class ElementTextItem;
class Diagram;
/**
This class manages the interactive movement of element text items on a
particular diagram.
*/
class ElementTextsMover {
// constructors, destructor
public:
ElementTextsMover();
virtual ~ElementTextsMover();
private:
ElementTextsMover(const ElementTextsMover &);
// methods
public:
bool isReady() const;
int beginMovement(Diagram *, QGraphicsItem * = 0);
void continueMovement(const QPointF &);
void endMovement();
// attributes
private:
bool movement_running_;
QPointF current_movement_;
Diagram *diagram_;
QGraphicsItem *movement_driver_;
QSet<ElementTextItem *> moved_texts_;
};
#endif

69
sources/qetgraphicsitem/diagramtextitem.cpp
View File

@ -17,7 +17,6 @@
*/
#include "diagramtextitem.h"
#include "diagramcommands.h"
#include "qet.h"
#include "qetapp.h"
#include "richtext/richtexteditor_p.h"
#include "diagram.h"
@ -30,7 +29,8 @@
DiagramTextItem::DiagramTextItem(QGraphicsItem *parent, Diagram *parent_diagram) :
QGraphicsTextItem(parent, parent_diagram),
previous_text_(),
rotation_angle_(0.0)
rotation_angle_(0.0),
m_first_move (true)
{
//set Zvalue at 10 to be upper than the DiagramImageItem
setZValue(10);
@ -260,6 +260,64 @@ void DiagramTextItem::mouseDoubleClickEvent(QGraphicsSceneMouseEvent *event) {
}
}
/**
* @brief DiagramTextItem::mousePressEvent
* @param event
*/
void DiagramTextItem::mousePressEvent (QGraphicsSceneMouseEvent *event) {
m_first_move = true;
if (event -> modifiers() & Qt::ControlModifier) {
setSelected(!isSelected());
}
QGraphicsTextItem::mousePressEvent(event);
}
/**
* @brief DiagramTextItem::mouseMoveEvent
* @param event
*/
void DiagramTextItem::mouseMoveEvent(QGraphicsSceneMouseEvent *event) {
if (textInteractionFlags() & Qt::TextEditable) QGraphicsTextItem::mouseMoveEvent(event);
else if ((flags() & QGraphicsItem::ItemIsMovable) && (event -> buttons() & Qt::LeftButton)) {
Diagram *diagram_ = diagram();
//This is first move, we signal it to parent diagram
if(diagram_ && m_first_move)
diagram_ -> beginMoveElements(this);
QPointF old_pos = pos();
//Save the pos of item at the beggining of the movement
if (m_first_move)
m_mouse_to_origin_movement = old_pos - event->buttonDownScenePos(Qt::LeftButton);
//Set the actual pos
setPos(event->scenePos() + m_mouse_to_origin_movement);
//Update the actual movement for other selected item
if (diagram_)
diagram_ -> continueMoveElements(pos() - old_pos);
}
else event -> ignore();
m_first_move = false;
}
/**
* @brief DiagramTextItem::mouseReleaseEvent
* @param event
*/
void DiagramTextItem::mouseReleaseEvent (QGraphicsSceneMouseEvent *event) {
//Signal to diagram movement is finish
if (diagram())
diagram() -> endMoveElements();
if (!(event -> modifiers() & Qt::ControlModifier))
QGraphicsTextItem::mouseReleaseEvent(event);
}
/**
Effectue la rotation du texte en elle-meme
Pour les DiagramTextItem, la rotation s'effectue autour du point (0, 0).
@ -297,13 +355,6 @@ void DiagramTextItem::setPos(qreal x, qreal y) {
setPos(QPointF(x, y));
}
/**
@return la position du champ de texte
*/
QPointF DiagramTextItem::pos() const {
return(QGraphicsTextItem::pos());
}
/// Rend le champ de texte non focusable
void DiagramTextItem::setNonFocusable() {
setFlag(QGraphicsTextItem::ItemIsFocusable, false);

12
sources/qetgraphicsitem/diagramtextitem.h
View File

@ -54,7 +54,6 @@ class DiagramTextItem : public QGraphicsTextItem {
virtual QDomElement toXml(QDomDocument &) const = 0;
virtual void setPos(const QPointF &);
virtual void setPos(qreal, qreal);
virtual QPointF pos() const;
qreal rotationAngle() const;
void setRotationAngle(const qreal &);
void rotateBy(const qreal &);
@ -70,7 +69,12 @@ class DiagramTextItem : public QGraphicsTextItem {
virtual void paint(QPainter *, const QStyleOptionGraphicsItem *, QWidget *);
virtual void focusInEvent(QFocusEvent *);
virtual void focusOutEvent(QFocusEvent *);
virtual void mouseDoubleClickEvent(QGraphicsSceneMouseEvent *);
virtual void mouseDoubleClickEvent (QGraphicsSceneMouseEvent *event);
virtual void mousePressEvent (QGraphicsSceneMouseEvent *event);
virtual void mouseMoveEvent (QGraphicsSceneMouseEvent *event);
virtual void mouseReleaseEvent (QGraphicsSceneMouseEvent *event);
virtual void applyRotation(const qreal &);
signals:
@ -83,11 +87,13 @@ class DiagramTextItem : public QGraphicsTextItem {
void setNonFocusable();
void setHtmlText(const QString &);
private:
protected:
/// Previous text value
QString previous_text_;
/// angle of rotation of the text field
qreal rotation_angle_;
bool no_editable;
bool m_first_move;
QPointF m_mouse_to_origin_movement;
};
#endif

120
sources/qetgraphicsitem/elementtextitem.cpp
View File

@ -16,9 +16,8 @@
along with QElectroTech. If not, see <http://www.gnu.org/licenses/>.
*/
#include "elementtextitem.h"
#include "diagram.h"
#include "diagramcommands.h"
#include "element.h"
#include <QTextDocument>
/**
Constructeur
@ -29,8 +28,7 @@ ElementTextItem::ElementTextItem(Element *parent_element, Diagram *parent_diagra
DiagramTextItem(parent_element, parent_diagram),
parent_element_(parent_element),
follow_parent_rotations(false),
original_rotation_angle_(0.0),
first_move_(true)
original_rotation_angle_(0.0)
{build();}
/**
@ -43,13 +41,10 @@ ElementTextItem::ElementTextItem(const QString &text, Element *parent_element, D
DiagramTextItem(text, parent_element, parent_diagram),
parent_element_(parent_element),
follow_parent_rotations(false),
original_rotation_angle_(0.0),
first_move_(true)
original_rotation_angle_(0.0)
{build();}
void ElementTextItem::build() {
setFlag(QGraphicsItem::ItemIsMovable, false);
setToolTip(tr("Maintenir ctrl pour d\351placer", "tool tip for element text item"));
adjustItemPosition(1);
// ajuste la position du QGraphicsItem lorsque le QTextDocument change
connect(document(), SIGNAL(blockCountChanged(int)), this, SLOT(adjustItemPosition(int)));
@ -84,13 +79,6 @@ void ElementTextItem::setPos(qreal x, qreal y) {
setPos(QPointF(x, y));
}
/**
@return La position (bidouillee) du champ de texte
*/
QPointF ElementTextItem::pos() const {
return(QGraphicsTextItem::pos());
}
/**
Permet de lire le texte a mettre dans le champ a partir d'un element XML.
Cette methode se base sur la position du champ pour assigner ou non la
@ -211,95 +199,23 @@ void ElementTextItem::applyRotation(const qreal &angle) {
}
/**
Gere le clic sur le champ de texte
@param e Objet decrivant l'evenement souris
*/
void ElementTextItem::mousePressEvent(QGraphicsSceneMouseEvent *e) {
first_move_ = true;
if (e -> modifiers() & Qt::ControlModifier) {
setSelected(true);
setFlag(QGraphicsItem::ItemIsMovable, true);
}
else DiagramTextItem::mousePressEvent(e);
* @brief ElementTextItem::mouseMoveEvent
* @param event
*/
void ElementTextItem::mouseMoveEvent(QGraphicsSceneMouseEvent *event) {
if (parent_element_)
parent_element_->setHighlighted(true);
DiagramTextItem::mouseMoveEvent(event);
}
/**
Gere les mouvements de souris lies au champ de texte
@param e Objet decrivant l'evenement souris
*/
void ElementTextItem::mouseMoveEvent(QGraphicsSceneMouseEvent *e) {
if (textInteractionFlags() & Qt::TextEditable) {
DiagramTextItem::mouseMoveEvent(e);
} else if ((flags() & QGraphicsItem::ItemIsMovable) && (e -> buttons() & Qt::LeftButton)) {
QPointF old_pos = pos();
/*
Utiliser e -> pos() directement aurait pour effet de positionner
l'origine du champ de texte a la position indiquee par le curseur,
ce qui n'est pas l'effet recherche
Au lieu de cela, on applique a la position actuelle le vecteur
definissant le mouvement effectue depuis la derniere position
cliquee avec le bouton gauche
*/
QPointF movement = e -> pos() - e -> buttonDownPos(Qt::LeftButton);
/*
Les methodes pos() et setPos() travaillent toujours avec les
coordonnees de l'item parent (ou de la scene s'il n'y a pas d'item
parent). On n'oublie donc pas de mapper le mouvement fraichement
calcule sur l'item parent avant de l'appliquer.
*/
QPointF parent_movement = mapMovementToParent(movement);
setPos(pos() + parent_movement);
Diagram *diagram_ptr = diagram();
if (diagram_ptr) {
if (first_move_) {
// on signale le debut d'un deplacement d'ElementTextItems au schema parent
int moved_texts_count = diagram_ptr -> beginMoveElementTexts(this);
// s'il n'y a qu'un seul texte deplace, on met en valeur l'element parent
if (moved_texts_count == 1 && parent_element_) {
parent_element_ -> setHighlighted(true);
parent_element_ -> update();
}
}
/*
Comme setPos() n'est pas oblige d'appliquer exactement la
valeur qu'on lui fournit, on calcule le mouvement reellement
applique.
*/
QPointF effective_movement = pos() - old_pos;
QPointF scene_effective_movement = mapMovementToScene(mapMovementFromParent(effective_movement));
// on applique le mouvement subi aux autres textes a deplacer
diagram_ptr -> continueMoveElementTexts(scene_effective_movement);
}
} else e -> ignore();
if (first_move_) {
first_move_ = false;
}
}
* @brief ElementTextItem::mouseReleaseEvent
* @param event
*/
void ElementTextItem::mouseReleaseEvent(QGraphicsSceneMouseEvent *event) {
if (parent_element_)
parent_element_->setHighlighted(false);
/**
Gere le relachement de souris
Cette methode cree un objet d'annulation pour le deplacement
@param e Objet decrivant l'evenement souris
*/
void ElementTextItem::mouseReleaseEvent(QGraphicsSceneMouseEvent *e) {
if (Diagram *diagram_ptr = diagram()) {
// on arrete de mettre en valeur l'element parent
if (parent_element_) {
if (parent_element_ -> isHighlighted()) {
parent_element_ -> setHighlighted(false);
}
}
diagram_ptr -> endMoveElementTexts();
}
if (!(e -> modifiers() & Qt::ControlModifier)) {
QGraphicsTextItem::mouseReleaseEvent(e);
}
setFlag(QGraphicsItem::ItemIsMovable, false);
DiagramTextItem::mouseReleaseEvent(event);
}

9
sources/qetgraphicsitem/elementtextitem.h
View File

@ -45,7 +45,6 @@ class ElementTextItem : public DiagramTextItem {
bool follow_parent_rotations;
QPointF original_position;
qreal original_rotation_angle_;
bool first_move_;
QString tagg_;
// methods
@ -60,7 +59,6 @@ class ElementTextItem : public DiagramTextItem {
QDomElement toXml(QDomDocument &) const;
void setPos(const QPointF &);
void setPos(qreal, qreal);
virtual QPointF pos() const;
void setOriginalPos(const QPointF &);
QPointF originalPos() const;
void setOriginalRotationAngle(const qreal &);
@ -74,10 +72,9 @@ class ElementTextItem : public DiagramTextItem {
protected:
virtual void applyRotation(const qreal &);
virtual void mousePressEvent(QGraphicsSceneMouseEvent *);
virtual void mouseMoveEvent(QGraphicsSceneMouseEvent *);
virtual void mouseReleaseEvent(QGraphicsSceneMouseEvent *);
virtual void focusOutEvent(QFocusEvent *e) {DiagramTextItem::focusOutEvent(e); setFlag(QGraphicsItem::ItemIsMovable, false);}
virtual void mouseMoveEvent (QGraphicsSceneMouseEvent *event);
virtual void mouseReleaseEvent (QGraphicsSceneMouseEvent *event);
private:
void build();

83
sources/qetgraphicsitem/independenttextitem.cpp
View File

@ -16,17 +16,15 @@
along with QElectroTech. If not, see <http://www.gnu.org/licenses/>.
*/
#include "independenttextitem.h"
#include "diagram.h"
#include <QDomElement>
/**
Constructeur
@param parent_diagram Le schema auquel est rattache le champ de texte
*/
IndependentTextItem::IndependentTextItem(Diagram *parent_diagram) :
DiagramTextItem(0, parent_diagram),
first_move_(true)
{
}
DiagramTextItem(0, parent_diagram)
{}
/**
Constructeur
@ -34,10 +32,8 @@ IndependentTextItem::IndependentTextItem(Diagram *parent_diagram) :
@param parent_diagram Le schema auquel est rattache le champ de texte
*/
IndependentTextItem::IndependentTextItem(const QString &text, Diagram *parent_diagram) :
DiagramTextItem(text, 0, parent_diagram),
first_move_(true)
{
}
DiagramTextItem(text, 0, parent_diagram)
{}
/// Destructeur
IndependentTextItem::~IndependentTextItem() {
@ -69,72 +65,3 @@ QDomElement IndependentTextItem::toXml(QDomDocument &document) const {
}
return(result);
}
/**
Gere le clic sur le champ de texte
@param e Objet decrivant l'evenement souris
*/
void IndependentTextItem::mousePressEvent(QGraphicsSceneMouseEvent *e) {
first_move_ = true;
if (e -> modifiers() & Qt::ControlModifier) {
setSelected(!isSelected());
}
DiagramTextItem::mousePressEvent(e);
}
/**
Gere les mouvements de souris lies au champ de texte
@param e Objet decrivant l'evenement souris
*/
void IndependentTextItem::mouseMoveEvent(QGraphicsSceneMouseEvent *e) {
if (textInteractionFlags() & Qt::TextEditable) {
DiagramTextItem::mouseMoveEvent(e);
} else if ((flags() & QGraphicsItem::ItemIsMovable) && isSelected() && (e -> buttons() & Qt::LeftButton)) {
// le champ de texte est en train d'etre deplace
Diagram *diagram_ptr = diagram();
if (diagram_ptr) {
if (first_move_) {
// il s'agit du premier mouvement du deplacement, on le signale
// au schema parent
diagram_ptr -> beginMoveElements(this);
}
}
// on applique le mouvement impose par la souris
QPointF old_pos = pos();
if (first_move_) {
mouse_to_origin_movement_ = old_pos - e -> buttonDownScenePos(Qt::LeftButton);
}
QPointF expected_pos = e-> scenePos() + mouse_to_origin_movement_;
setPos(expected_pos); // setPos() will snap the expected position to the grid
// on calcule le mouvement reellement applique par setPos()
QPointF effective_movement = pos() - old_pos;
if (diagram_ptr) {
// on signale le mouvement ainsi applique au schema parent, qui
// l'appliquera aux autres items selectionnes selon son bon vouloir
diagram_ptr -> continueMoveElements(effective_movement);
}
} else e -> ignore();
if (first_move_) {
first_move_ = false;
}
}
/**
Gere le relachement de souris
Cette methode a ete reimplementee pour tenir a jour la liste des elements
et conducteurs a deplacer au niveau du schema.
@param e Objet decrivant l'evenement souris
*/
void IndependentTextItem::mouseReleaseEvent(QGraphicsSceneMouseEvent *e) {
if (flags() & QGraphicsItem::ItemIsMovable) {
if (Diagram *diagram_ptr = diagram()) {
diagram_ptr -> endMoveElements();
}
}
if (!(e -> modifiers() & Qt::ControlModifier)) {
DiagramTextItem::mouseReleaseEvent(e);
}
}

6
sources/qetgraphicsitem/independenttextitem.h
View File

@ -47,13 +47,7 @@ class IndependentTextItem : public DiagramTextItem {
virtual void fromXml(const QDomElement &);
virtual QDomElement toXml(QDomDocument &) const;
protected:
virtual void mousePressEvent(QGraphicsSceneMouseEvent *);
virtual void mouseMoveEvent(QGraphicsSceneMouseEvent *);
virtual void mouseReleaseEvent(QGraphicsSceneMouseEvent *);
private:
bool first_move_;
QPointF mouse_to_origin_movement_;
};
#endif