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

Revert "Merge branch 'XMLPropertiesNew'"

Browse Source 
**Break a lot of thing.**

This reverts commit 1db1800572, reversing
changes made to 4c563821e8.
This commit is contained in:
joshua
2021-03-11 19:52:50 +01:00
parent 83b69253dc
commit 11b8ef927b
88 changed files with 1587 additions and 2778 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
sources/QetGraphicsItemModeler/qetgraphicshandleritem.h
View File

@@ -53,7 +53,7 @@ class QetGraphicsHandlerItem : public QGraphicsItem
QRectF m_handler_rect,
m_br;
qreal m_size;
QColor m_color{Qt::black};
QColor m_color;
QPen m_pen;
public:

50
sources/borderproperties.cpp
View File

@@ -16,7 +16,6 @@
along with QElectroTech. If not, see <http://www.gnu.org/licenses/>.
*/
#include "borderproperties.h"
#include "qetxml.h"
/**
@brief BorderProperties::BorderProperties
@@ -33,7 +32,15 @@
- 17 colonnes affichees de 60.0 px de large pour 20.0px de haut
- 8 lignes affichees de 80.0 px de haut pour 20.0px de large
*/
BorderProperties::BorderProperties(): PropertiesInterface("border")
BorderProperties::BorderProperties() :
columns_count(17),
columns_width(60.0),
columns_header_height(20.0),
display_columns(true),
rows_count(8),
rows_height(80.0),
rows_header_width(20.0),
display_rows(true)
{
}
@@ -81,7 +88,7 @@ bool BorderProperties::operator!=(const BorderProperties &bp) {
}
/**
@brief BorderProperties::toXmlPriv
@brief BorderProperties::toXml
Exports dimensions as XML attributes added to element e.
\~French Exporte les dimensions sous formes d'attributs XML ajoutes a l'element e.
@@ -89,7 +96,8 @@ bool BorderProperties::operator!=(const BorderProperties &bp) {
XML element to which attributes will be added
\~French Element XML auquel seront ajoutes des attributs
*/
void BorderProperties::toXmlPriv(QDomElement& e) const {
void BorderProperties::toXml(QDomElement &e) const
{
e.setAttribute("cols", columns_count);
e.setAttribute("colsize", QString("%1").arg(columns_width));
e.setAttribute("rows", rows_count);
@@ -98,8 +106,8 @@ void BorderProperties::toXmlPriv(QDomElement& e) const {
e.setAttribute("displayrows", display_rows ? "true" : "false");
}
/*!RETURNS True
@brief BorderProperties::fromXmlPriv
/**
@brief BorderProperties::fromXml
Import dimensions from XML attributes of element e
\~French Importe les dimensions a partir des attributs XML de l'element e
@@ -107,29 +115,13 @@ void BorderProperties::toXmlPriv(QDomElement& e) const {
XML element whose attributes will be read
\~French Element XML dont les attributs seront lus
*/
bool BorderProperties::fromXmlPriv(const QDomElement &e) {
if (QETXML::propertyInteger(e, "cols", &columns_count) == QETXML::PropertyFlags::NoValidConversion ||
QETXML::propertyDouble(e, "colsize", &columns_width) == QETXML::PropertyFlags::NoValidConversion ||
QETXML::propertyInteger(e, "rows", &rows_count) == QETXML::PropertyFlags::NoValidConversion ||
QETXML::propertyDouble(e, "rowsize", &rows_height) == QETXML::PropertyFlags::NoValidConversion ||
QETXML::propertyBool(e, "displaycols", &display_columns) == QETXML::PropertyFlags::NoValidConversion ||
QETXML::propertyBool(e, "displayrows", &display_rows) == QETXML::PropertyFlags::NoValidConversion)
return false;
return true;
}
bool BorderProperties::valideXml(QDomElement& e) {
if (QETXML::propertyInteger(e, "cols") == QETXML::PropertyFlags::Success ||
QETXML::propertyDouble(e, "colsize") == QETXML::PropertyFlags::Success ||
QETXML::propertyInteger(e, "rows") == QETXML::PropertyFlags::Success ||
QETXML::propertyDouble(e, "rowsize") == QETXML::PropertyFlags::Success ||
QETXML::propertyBool(e, "displaycols") == QETXML::PropertyFlags::Success ||
QETXML::propertyBool(e, "displayrows") == QETXML::PropertyFlags::Success)
return true;
return false;
void BorderProperties::fromXml(QDomElement &e) {
if (e.hasAttribute("cols")) columns_count = e.attribute("cols").toInt();
if (e.hasAttribute("colsize")) columns_width = e.attribute("colsize").toInt();
if (e.hasAttribute("rows")) rows_count = e.attribute("rows").toInt();
if (e.hasAttribute("rowsize")) rows_height = e.attribute("rowsize").toInt();
if (e.hasAttribute("displaycols")) display_columns = e.attribute("displaycols") == "true";
if (e.hasAttribute("displayrows")) display_rows = e.attribute("displayrows") == "true";
}
/**

29
sources/borderproperties.h
View File

@@ -20,15 +20,13 @@
#include <QtCore>
#include <QtXml>
#include "properties/propertiesinterface.h"
/**
@brief The BorderProperties class
This class is a container for dimensions and display properties of a
diagram.
@remark Attributes are public
*/
class BorderProperties : public PropertiesInterface {
class BorderProperties {
public:
// constructor, destructor, operators
BorderProperties();
@@ -37,23 +35,22 @@ class BorderProperties : public PropertiesInterface {
bool operator==(const BorderProperties &);
bool operator!=(const BorderProperties &);
void toXmlPriv(QDomElement&) const override;
bool fromXmlPriv(const QDomElement &) override;
static bool valideXml(QDomElement& e);
void toSettings(QSettings &, const QString & = QString()) const override;
void fromSettings(QSettings &, const QString & = QString()) override;
void toXml(QDomElement &) const;
void fromXml(QDomElement &);
void toSettings(QSettings &, const QString & = QString()) const;
void fromSettings(QSettings &, const QString & = QString());
static BorderProperties defaultProperties();
// attributes
int columns_count{17}; ///< Columns count
qreal columns_width{60.0}; ///< Columns width
qreal columns_header_height{20.0}; ///< Column headers height
bool display_columns{true}; ///< Whether to display column headers
int columns_count; ///< Columns count
qreal columns_width; ///< Columns width
qreal columns_header_height; ///< Column headers height
bool display_columns; ///< Whether to display column headers
int rows_count{8}; ///< Rows count
qreal rows_height{80.0}; ///< Rows height
qreal rows_header_width{20.0}; ///< Row headers width
bool display_rows{true}; ///< Whether to display row headers
int rows_count; ///< Rows count
qreal rows_height; ///< Rows height
qreal rows_header_width; ///< Row headers width
bool display_rows; ///< Whether to display row headers
};
#endif

20
sources/bordertitleblock.cpp
View File

@@ -65,6 +65,8 @@ BorderTitleBlock::BorderTitleBlock(QObject *parent) :
// contenu par defaut du cartouche
importTitleBlock(TitleBlockProperties());
display_titleblock_ = true;
display_border_ = true;
setFolioData(1, 1);
updateRectangles();
}
@@ -205,8 +207,8 @@ QRectF BorderTitleBlock::insideBorderRect() const
Exports the title block current values to XML.
@param xml_elmt the XML element attributes will be added to
*/
QDomElement BorderTitleBlock::titleBlockToXml(QDomDocument& doc) {
return exportTitleBlock().toXml(doc);
void BorderTitleBlock::titleBlockToXml(QDomElement &xml_elmt) {
exportTitleBlock().toXml(xml_elmt);
}
/**
@@ -215,24 +217,10 @@ QDomElement BorderTitleBlock::titleBlockToXml(QDomDocument& doc) {
@param xml_elmt the XML element values will be read from
*/
void BorderTitleBlock::titleBlockFromXml(const QDomElement &xml_elmt) {
TitleBlockProperties tbp;
QString tagname = tbp.tagName();
QDomElement titleBlockProperties = xml_elmt.firstChildElement(tagname);
if (!titleBlockProperties.isNull())
{
tbp.fromXml(titleBlockProperties);
importTitleBlock(tbp);
}
else
{
// legacy
// Remove this part in a later step
tbp.fromXml(xml_elmt);
importTitleBlock(tbp);
}
}
/**
@brief BorderTitleBlock::borderToXml

6
sources/bordertitleblock.h
View File

@@ -174,7 +174,7 @@ class BorderTitleBlock : public QObject
void setPreviousFolioNum(const QString &previous);
void setNextFolioNum(const QString &next);
QDomElement titleBlockToXml(QDomDocument &doc);
void titleBlockToXml(QDomElement &);
void titleBlockFromXml(const QDomElement &);
void borderToXml(QDomElement &);
void borderFromXml(const QDomElement &);
@@ -286,10 +286,10 @@ class BorderTitleBlock : public QObject
QRectF diagram_rect_;
// display options
bool display_titleblock_{true};
bool display_titleblock_;
bool display_columns_;
bool display_rows_;
bool display_border_{true};
bool display_border_;
TitleBlockTemplateRenderer *m_titleblock_template_renderer;
};
#endif

188
sources/conductorproperties.cpp
View File

@@ -20,16 +20,14 @@
#include <QMetaEnum>
#include <QRegularExpression>
#include <QtDebug>
#include "qetxml.h"
namespace {
const QString conductorPropertiesXmlName = "conductorProperties";
}
/**
Constructeur par defaut
*/
SingleLineProperties::SingleLineProperties(): PropertiesInterface("SingleLine")
SingleLineProperties::SingleLineProperties() :
hasGround(true),
hasNeutral(true),
is_pen(false),
phases(1)
{
}
@@ -217,8 +215,8 @@ void SingleLineProperties::drawPen(QPainter *painter,
ajoutes a l'element e.
@param e Element XML auquel seront ajoutes des attributs
*/
void SingleLineProperties::toXmlPriv(QDomElement& e) const {
void SingleLineProperties::toXml(QDomElement &e) const
{
e.setAttribute("ground", hasGround ? "true" : "false");
e.setAttribute("neutral", hasNeutral ? "true" : "false");
e.setAttribute("phase", phases);
@@ -230,36 +228,11 @@ void SingleLineProperties::toXmlPriv(QDomElement& e) const {
de l'element e
@param e Element XML dont les attributs seront lus
*/
bool SingleLineProperties::fromXmlPriv(const QDomElement &e) {
if (QETXML::propertyBool(e, "ground", &hasGround) != QETXML::PropertyFlags::Success ||
QETXML::propertyBool(e, "neutral", &hasNeutral) != QETXML::PropertyFlags::Success)
return false;
int phase;
if (QETXML::propertyInteger(e, "phase", &phase) != QETXML::PropertyFlags::Success)
return false;
setPhasesCount(phase);
bool pen;
if (QETXML::propertyBool(e, "pen", &pen) != QETXML::PropertyFlags::Success)
return false;
is_pen = (hasGround && hasNeutral && pen);
return true;
}
bool SingleLineProperties::valideXml(QDomElement& e) {
if (QETXML::propertyBool(e, "ground") != QETXML::PropertyFlags::Success ||
QETXML::propertyBool(e, "neutral") != QETXML::PropertyFlags::Success)
return false;
if (QETXML::propertyInteger(e, "phase") != QETXML::PropertyFlags::Success)
return false;
if (QETXML::propertyBool(e, "pen") != QETXML::PropertyFlags::Success)
return false;
return true;
void SingleLineProperties::fromXml(QDomElement &e) {
hasGround = e.attribute("ground") == "true";
hasNeutral = e.attribute("neutral") == "true";
setPhasesCount(e.attribute("phase").toInt());
is_pen = (hasGround && hasNeutral && e.attribute("pen", "false") == "true");
}
/**
@@ -267,7 +240,17 @@ bool SingleLineProperties::valideXml(QDomElement& e) {
multifilaire noir dont le texte est "_"
*/
ConductorProperties::ConductorProperties() :
PropertiesInterface(xmlTagName())
type(Multi),
color(Qt::black),
text_color(Qt::black),
text("_"),
text_size(9),
cond_size(1),
verti_rotate_text(270),
horiz_rotate_text(0),
m_show_text(true),
m_one_text_per_folio(false),
style(Qt::SolidLine)
{}
/**
@@ -283,9 +266,8 @@ ConductorProperties::~ConductorProperties()
Export conductor propertie, in the XML element 'e'
@param e the xml element
*/
void ConductorProperties::toXmlPriv(QDomElement& e) const
void ConductorProperties::toXml(QDomElement &e) const
{
e.setAttribute("type", typeToString(type));
if (color != QColor(Qt::black))
@@ -296,10 +278,7 @@ void ConductorProperties::toXmlPriv(QDomElement& e) const
e.setAttribute("dash-size", QString::number(m_dash_size));
if (type == Single)
{
QDomDocument doc = e.ownerDocument();
singleLineProperties.toXml(doc);
}
singleLineProperties.toXml(e);
e.setAttribute("num", text);
e.setAttribute("text_color", text_color.name());
@@ -327,99 +306,68 @@ void ConductorProperties::toXmlPriv(QDomElement& e) const
}
/** RETURNS True
/**
@brief ConductorProperties::fromXml
Import conductor propertie, from the attribute of the xml element 'e'
@param e the xml document
*/
bool ConductorProperties::fromXmlPriv(const QDomElement &e)
void ConductorProperties::fromXml(QDomElement &e)
{
// get conductor color
QETXML::propertyColor(e, "color", &color);
QETXML::propertyBool(e, "bicolor", &m_bicolor);
QETXML::propertyColor(e, "color2", &m_color_2);
QETXML::propertyInteger(e, "dash-size", &m_dash_size);
QColor xml_color= QColor(e.attribute("color"));
color = (xml_color.isValid()? xml_color : QColor(Qt::black));
QString bicolor_str = e.attribute("bicolor", "false");
m_bicolor = bicolor_str == "true"? true : false;
QColor xml_color_2 = QColor(e.attribute("color2"));
m_color_2 = xml_color_2.isValid()? xml_color_2 : QColor(Qt::black);
m_dash_size = e.attribute("dash-size", QString::number(1)).toInt();
// read style of conductor
QString style_string;
QETXML::propertyString(e, "style", &style_string);
readStyle(style_string);
readStyle(e.attribute("style"));
QString type_t;
if (QETXML::propertyString(e, "type", &type_t) == QETXML::PropertyFlags::Success) {
if (type_t == typeToString(Single))
if (e.attribute("type") == typeToString(Single))
{
// get specific properties for single conductor
singleLineProperties.fromXml(e);
type = Single;
}
else if (type_t == typeToString(Multi))
else
type = Multi;
else {
//Keep retrocompatible with version older than 0,4
//If the propertie @type is simple (removed since QET 0,4), we set text no visible.
//@TODO remove this code for qet 0.6 or later
if (type_t == "simple") m_show_text = false;
}
}
QETXML::propertyString(e, "num", &text);
// TODO: implement:
//m_cable = e.attribute("cable");
//m_bus = e.attribute("bus");
text = e.attribute("num");
// get text color
QETXML::propertyColor(e, "text_color", &text_color);
QETXML::propertyString(e, "formula", &m_formula);
QETXML::propertyString(e, "function", &m_function);
QETXML::propertyString(e, "tension_protocol", &m_tension_protocol);
QETXML::propertyString(e, "conductor_color", &m_wire_color);
QETXML::propertyString(e, "conductor_section", &m_wire_section);
QETXML::propertyInteger(e, "numsize", &text_size);
QETXML::propertyDouble(e, "condsize", &cond_size);
QETXML::propertyBool(e, "displaytext", &m_show_text);
QETXML::propertyBool(e, "onetextperfolio", &m_one_text_per_folio);
QETXML::propertyDouble(e, "vertirotatetext", &verti_rotate_text);
QETXML::propertyDouble(e, "horizrotatetext", &horiz_rotate_text);
QColor xml_text_color= QColor(e.attribute("text_color"));
text_color = (xml_text_color.isValid()? xml_text_color : QColor(Qt::black));
m_formula = e.attribute("formula");
m_cable = e.attribute("cable");
m_bus = e.attribute("bus");
m_function = e.attribute("function");
m_tension_protocol = e.attribute("tension_protocol");
m_wire_color = e.attribute("conductor_color");
m_wire_section = e.attribute("conductor_section");
text_size = e.attribute("numsize", QString::number(9)).toInt();
cond_size = e.attribute("condsize", QString::number(1)).toDouble();
m_show_text = e.attribute("displaytext", QString::number(1)).toInt();
m_one_text_per_folio = e.attribute("onetextperfolio", QString::number(0)).toInt();
verti_rotate_text = e.attribute("vertirotatetext").toDouble();
horiz_rotate_text = e.attribute("horizrotatetext").toDouble();
QMetaEnum me = QMetaEnum::fromType<Qt::Alignment>();
QString alinment_temp;
if (QETXML::propertyString(e, "horizontal-alignment", &alinment_temp) == QETXML::PropertyFlags::Success)
m_horizontal_alignment = Qt::Alignment(me.keyToValue(alinment_temp.toStdString().data()));
if (QETXML::propertyString(e, "vertical-alignment", &alinment_temp) == QETXML::PropertyFlags::Success)
m_vertical_alignment = Qt::Alignment(me.keyToValue(alinment_temp.toStdString().data()));
return true;
}
bool ConductorProperties::valideXml(QDomElement& e) {
if (QETXML::propertyColor(e, "color") ||
QETXML::propertyBool(e, "bicolor") ||
QETXML::propertyColor(e, "color2") ||
QETXML::propertyInteger(e, "dash-size") ||
QETXML::propertyString(e, "type") ||
QETXML::propertyString(e, "num") ||
QETXML::propertyColor(e, "text_color") ||
QETXML::propertyString(e, "formula") ||
QETXML::propertyString(e, "function") ||
QETXML::propertyString(e, "tension_protocol") ||
QETXML::propertyString(e, "conductor_color") ||
QETXML::propertyString(e, "conductor_section") ||
QETXML::propertyInteger(e, "numsize") ||
QETXML::propertyDouble(e, "condsize") ||
QETXML::propertyBool(e, "displaytext") ||
QETXML::propertyBool(e, "onetextperfolio") ||
QETXML::propertyDouble(e, "vertirotatetext") ||
QETXML::propertyDouble(e, "horizrotatetext") ||
QETXML::propertyString(e, "horizontal-alignment") ||
QETXML::propertyString(e, "vertical-alignment"))
return false;
return true;
}
QString ConductorProperties::xmlTagName()
{
return conductorPropertiesXmlName;
m_horizontal_alignment = Qt::Alignment(
me.keyToValue(
e.attribute(
"horizontal-alignment",
"AlignBottom"
).toStdString().data()));
m_vertical_alignment = Qt::Alignment(
me.keyToValue(
e.attribute(
"vertical-alignment",
"AlignRight"
).toStdString().data()));
}
/**

59
sources/conductorproperties.h
View File

@@ -22,15 +22,13 @@
#include <QColor>
#include <QSettings>
#include "properties/propertiesinterface.h"
class QPainter;
/**
@brief The SingleLineProperties class
This class represents the properties of a singleline conductor.
*/
class SingleLineProperties: public PropertiesInterface {
class SingleLineProperties {
public:
SingleLineProperties();
virtual ~SingleLineProperties();
@@ -39,24 +37,23 @@ class SingleLineProperties: public PropertiesInterface {
unsigned short int phasesCount();
bool isPen() const;
void draw(QPainter *, QET::ConductorSegmentType, const QRectF &);
void toXmlPriv(QDomElement&) const override;
bool fromXmlPriv(const QDomElement &) override;
static bool valideXml(QDomElement& element);
void toXml(QDomElement &) const;
void fromXml(QDomElement &);
void toSettings(QSettings &, const QString & = QString()) const;
void fromSettings(QSettings &, const QString & = QString());
/// Whether the singleline conductor should display the ground symbol
bool hasGround{true};
bool hasGround;
/// Whether the singleline conductor should display the neutral symbol
bool hasNeutral{true};
bool hasNeutral;
/// Protective Earth Neutral: visually merge neutral and ground
bool is_pen{false};
bool is_pen;
int operator==(const SingleLineProperties &) const;
int operator!=(const SingleLineProperties &) const;
private:
unsigned short int phases{1};
unsigned short int phases;
void drawGround (QPainter *, QET::ConductorSegmentType, QPointF, qreal);
void drawNeutral(QPainter *, QPointF, qreal);
void drawPen(QPainter *, QET::ConductorSegmentType, QPointF, qreal);
@@ -67,7 +64,7 @@ class SingleLineProperties: public PropertiesInterface {
This class represents the functional properties of a particular conductor,
i.e. properties other than path and terminals.
*/
class ConductorProperties: public PropertiesInterface
class ConductorProperties
{
public:
ConductorProperties();
@@ -83,15 +80,15 @@ class ConductorProperties: public PropertiesInterface
//Attributes
ConductorType type{ConductorType::Multi};
ConductorType type;
// TODO: set default values!
QColor color{QColor(Qt::black)},
m_color_2{QColor(Qt::black)},
text_color{QColor(Qt::black)};
QColor
color,
m_color_2,
text_color;
QString
text{"_"},
text,
m_function,
m_tension_protocol,
m_wire_color,
@@ -100,31 +97,33 @@ class ConductorProperties: public PropertiesInterface
m_bus,
m_cable;
int text_size{9},
int
text_size,
m_dash_size = 1;
double
cond_size{1},
verti_rotate_text{270},
horiz_rotate_text{0};
cond_size,
verti_rotate_text,
horiz_rotate_text;
bool m_show_text{true},
m_one_text_per_folio{false},
bool
m_show_text,
m_one_text_per_folio,
m_bicolor = false;
Qt::Alignment
m_horizontal_alignment = Qt::AlignBottom,
m_vertical_alignment = Qt::AlignRight;
Qt::PenStyle style{Qt::PenStyle::SolidLine};
Qt::PenStyle style;
SingleLineProperties singleLineProperties;
// methods
static bool valideXml(QDomElement& element);
static QString xmlTagName();
void toSettings(QSettings &, const QString & = QString()) const override;
void fromSettings(QSettings &, const QString & = QString()) override;
void toXml(QDomElement &) const;
void fromXml(QDomElement &);
void toSettings(QSettings &, const QString & = QString()) const;
void fromSettings(QSettings &, const QString & = QString());
static QString typeToString(ConductorType);
void applyForEqualAttributes(QList<ConductorProperties> list);
@@ -134,10 +133,6 @@ class ConductorProperties: public PropertiesInterface
bool operator==(const ConductorProperties &) const;
bool operator!=(const ConductorProperties &) const;
private:
void toXmlPriv(QDomElement&) const override;
bool fromXmlPriv(const QDomElement &) override;
private:
void readStyle(const QString &);
QString writeStyle() const;

46
sources/diagram.cpp
View File

@@ -44,8 +44,6 @@
#include <cassert>
#include <math.h>
#include "qetxml.h"
int Diagram::xGrid = 10;
int Diagram::yGrid = 10;
int Diagram::xKeyGrid = 10;
@@ -739,13 +737,14 @@ QDomDocument Diagram::toXml(bool whole_content) {
// schema properties
// proprietes du schema
if (whole_content) {
// TODO: compare with old version
dom_root.appendChild(border_and_titleblock.titleBlockToXml(document));
border_and_titleblock.titleBlockToXml(dom_root);
border_and_titleblock.borderToXml(dom_root);
// Default conductor properties
defaultConductorProperties.setTagName("defaultconductor");
dom_root.appendChild(defaultConductorProperties.toXml(document));
QDomElement default_conductor =
document.createElement("defaultconductor");
defaultConductorProperties.toXml(default_conductor);
dom_root.appendChild(default_conductor);
// Conductor autonum
if (!m_conductors_autonum_name.isEmpty()) {
@@ -919,11 +918,13 @@ QDomDocument Diagram::toXml(bool whole_content) {
// correspondence table between the addresses of the terminals and their ids
// table de correspondance entre les adresses des bornes et leurs ids
QHash<Terminal *, int> table_adr_id;
if (!list_elements.isEmpty()) {
auto dom_elements = document.createElement("elements");
for (auto elmt : list_elements) {
dom_elements.appendChild(elmt->toXml(document));
dom_elements.appendChild(elmt->toXml(document,
table_adr_id));
}
dom_root.appendChild(dom_elements);
}
@@ -931,7 +932,8 @@ QDomDocument Diagram::toXml(bool whole_content) {
if (!list_conductors.isEmpty()) {
auto dom_conductors = document.createElement("conductors");
for (auto cond : list_conductors) {
dom_conductors.appendChild(cond->toXml(document));
dom_conductors.appendChild(cond->toXml(document,
table_adr_id));
}
dom_root.appendChild(dom_conductors);
}
@@ -1094,7 +1096,7 @@ bool Diagram::initFromXml(QDomElement &document,
@return
*/
Terminal* findTerminal(int conductor_index,
QDomElement& conductor,
QDomElement& f,
QHash<int,
Terminal *>& table_adr_id,
QList<Element *>& added_elements) {
@@ -1103,8 +1105,8 @@ Terminal* findTerminal(int conductor_index,
QString element_index = "element" + QString::number(conductor_index);
QString terminal_index = "terminal" + QString::number(conductor_index);
QUuid element_uuid;
if (QETXML::propertyUuid(conductor, element_index, &element_uuid) == QETXML::PropertyFlags::Success) {
if (f.hasAttribute(element_index)) {
QUuid element_uuid = QUuid(f.attribute(element_index));
// element1 did not exist in the conductor part of the xml until prior 0.7
// It is used as an indicator that uuid's are used to identify terminals
bool element_found = false;
@@ -1112,8 +1114,7 @@ Terminal* findTerminal(int conductor_index,
if (element->uuid() != element_uuid)
continue;
element_found = true;
QUuid terminal_uuid;
QETXML::propertyUuid(conductor, terminal_index, &terminal_uuid);
QUuid terminal_uuid = QUuid(f.attribute(terminal_index));
for (auto terminal: element->terminals()) {
if (terminal->uuid() != terminal_uuid)
continue;
@@ -1137,11 +1138,9 @@ Terminal* findTerminal(int conductor_index,
<< element_uuid
<< "not found";
} else {
// Backward compatibility. Until version 0.7 a generated id is used to link the terminal.
int id_p1 = -1;
if (QETXML::propertyInteger(conductor, terminal_index, &id_p1) != QETXML::PropertyFlags::Success) {
qDebug() << "diagramm.cpp:findTerminal(): Reading Id was not successfull";
}
// Backward compatibility.
// Until version 0.7 a generated id is used to link the terminal.
int id_p1 = f.attribute(terminal_index).toInt();
if (!table_adr_id.contains(id_p1)) {
qDebug() << "Diagram::fromXml() : terminal id "
<< id_p1
@@ -1149,7 +1148,6 @@ Terminal* findTerminal(int conductor_index,
} else
return table_adr_id.value(id_p1);
}
qDebug() << "Diagram::findTerminal(): No terminal found.";
return nullptr;
}
@@ -1192,13 +1190,10 @@ bool Diagram::fromXml(QDomElement &document,
// The first element must be a diagram
if (root.tagName() != "diagram") return(false);
qDebug() << "Diagram::fromXml; Diagram: " << root.attribute("title");
// Read attributes of this diagram
if (consider_informations)
{
// Load border and titleblock
border_and_titleblock.titleBlockFromXml(root);
border_and_titleblock.borderFromXml(root);
@@ -1210,7 +1205,6 @@ bool Diagram::fromXml(QDomElement &document,
defaultConductorProperties.fromXml(default_conductor_elmt);
}
// Load the autonum
m_conductors_autonum_name = root.attribute("conductorAutonum");
@@ -1385,7 +1379,7 @@ bool Diagram::fromXml(QDomElement &document,
Terminal* p1 = findTerminal(1, f, table_adr_id, added_elements);
Terminal* p2 = findTerminal(2, f, table_adr_id, added_elements);
if (p1 && p2 && p1 != p2)// TODO: why the condition for unequal is required?
if (p1 && p2 && p1 != p2)
{
Conductor *c = new Conductor(p1, p2);
if (c->isValid())
@@ -1396,8 +1390,6 @@ bool Diagram::fromXml(QDomElement &document,
}
else
delete c;
} else {
qDebug() << "Diagramm::fromXML(): No matching terminals found.";
}
}
@@ -1537,7 +1529,7 @@ void Diagram::refreshContents()
/**
@brief Diagram::addItem
R??implemented from QGraphicsScene::addItem(QGraphicsItem *item)
Réimplemented from QGraphicsScene::addItem(QGraphicsItem *item)
Do some specific operation if item need it (for exemple an element)
@param item
*/

4
sources/diagram.h
View File

@@ -96,7 +96,7 @@ class Diagram : public QGraphicsScene
/// margin around the diagram
static const qreal margin;
/// background color of diagram
static QColor background_color; // default value set in cpp file
static QColor background_color;
/// Hash containing max values for folio sequential autonums in this diagram
QHash <QString, QStringList> m_elmt_unitfolio_max;
QHash <QString, QStringList> m_elmt_tenfolio_max;
@@ -282,8 +282,6 @@ class Diagram : public QGraphicsScene
/// from the diagram within elements collection
void findElementRequired(const ElementsLocation &);
/// Signal emitted when users wish to edit an element from the diagram
void editElementRequired(const ElementsLocation &);
void diagramActivated();
};
Q_DECLARE_METATYPE(Diagram *)

2
sources/editor/arceditor.cpp
View File

@@ -210,7 +210,7 @@ void ArcEditor::updateArcA()
@brief ArcEditor::updateForm
Update the value of the widgets
*/
void ArcEditor::updateFormPriv()
void ArcEditor::updateForm()
{
if (!m_part) return;
activeConnections(false);

4
sources/editor/arceditor.h
View File

@@ -47,6 +47,8 @@ class ArcEditor : public ElementItemEditor
QSpinBox *angle, *start_angle;
bool m_locked;
QList <QMetaObject::Connection> m_change_connections;
// methods
public:
bool setPart(CustomElementPart *) override;
@@ -57,7 +59,7 @@ class ArcEditor : public ElementItemEditor
public slots:
void updateArcS();
void updateArcA();
void updateFormPriv() override;
void updateForm() override;
void updateRect();
private:

5
sources/editor/elementitemeditor.cpp
View File

@@ -42,11 +42,6 @@ ElementScene *ElementItemEditor::elementScene() const
return(element_editor -> elementScene());
}
void ElementItemEditor::updateForm()
{
updateFormPriv();
}
/// @return la QUndoStack a utiliser pour les annulations
QUndoStack &ElementItemEditor::undoStack() const
{

10
sources/editor/elementitemeditor.h
View File

@@ -55,16 +55,8 @@ class ElementItemEditor : public QWidget
virtual CustomElementPart *currentPart() const = 0;
virtual QList<CustomElementPart*> currentParts() const = 0;
/*!
* \brief updateForm
* update the values of the widget
*/
virtual void updateForm();
private:
virtual void updateFormPriv() = 0;
virtual void updateForm() = 0;
protected:
QList<QMetaObject::Connection> m_change_connections;
// attributes
private:
QETElementEditor *element_editor;

4
sources/editor/graphicspart/abstractpartellipse.h
View File

@@ -79,8 +79,8 @@ class AbstractPartEllipse : public CustomElementGraphicPart
protected:
QList<QPointF> saved_points_;
QRectF m_rect;
qreal m_start_angle{0};
qreal m_span_angle{-1440};
qreal m_start_angle;
qreal m_span_angle;
QVector<QetGraphicsHandlerItem *> m_handler_vector;
};

8
sources/editor/graphicspart/customelementgraphicpart.cpp
View File

@@ -20,8 +20,6 @@
#include "../../QPropertyUndoCommand/qpropertyundocommand.h"
#include "../elementscene.h"
#include "../../qetxml.h"
#include <QRegularExpression>
/**
@@ -499,6 +497,7 @@ void CustomElementGraphicPart::stylesToXml(QDomElement &qde) const
else if (_color == HTMLGrayBlackColor) css_like_styles += "HTMLGrayBlack";
else if (_color == NoneColor) css_like_styles += "none";
qde.setAttribute("style", css_like_styles);
qde.setAttribute("antialias", _antialiased ? "true" : "false");
}
@@ -513,9 +512,6 @@ void CustomElementGraphicPart::stylesFromXml(const QDomElement &qde)
{
resetStyles();
QString style_string;
QETXML::propertyString(qde, "style", &style_string);
//Get the list of pair style/value
#if QT_VERSION < QT_VERSION_CHECK(5, 14, 0) // ### Qt 6: remove
QStringList styles = qde.attribute("style").split(";", QString::SkipEmptyParts);
@@ -1316,7 +1312,7 @@ void CustomElementGraphicPart::mouseReleaseEvent(QGraphicsSceneMouseEvent *event
if((event->button() & Qt::LeftButton) && (flags() & QGraphicsItem::ItemIsMovable) && m_origin_pos != pos())
{
QPropertyUndoCommand *undo = new QPropertyUndoCommand(this, "pos", QVariant(m_origin_pos), QVariant(pos()));
undo->setText(tr("D??placer une primitive"));
undo->setText(tr("Déplacer une primitive"));
undo->enableAnimation();
elementScene()->undoStack().push(undo);
}

11
sources/editor/graphicspart/customelementpart.h
View File

@@ -19,7 +19,6 @@
#define CUSTOM_ELEMENT_PART_H
#include "../../qet.h"
#include "../../properties/propertiesinterface.h"
class CustomElement;
class ElementPrimitiveDecorator;
@@ -38,7 +37,7 @@ class QGraphicsSceneMouseEvent;
there is no point for those classes to store their visual representation
with anything more complex than a QImage.
*/
class CustomElementPart: public PropertiesInterface {
class CustomElementPart {
// constructors, destructor
public:
/**
@@ -62,6 +61,14 @@ class CustomElementPart: public PropertiesInterface {
// methods
public:
/**
Load the primitive from an XML element that describes it
*/
virtual void fromXml(const QDomElement &) = 0;
/**
Export the primitive as an XML element
*/
virtual const QDomElement toXml(QDomDocument &) const = 0;
/**
Set a specific property of the primitive
*/

50
sources/editor/graphicspart/partarc.cpp
View File

@@ -22,8 +22,6 @@
#include "../../QetGraphicsItemModeler/qetgraphicshandlerutility.h"
#include "../elementscene.h"
#include "../../qetxml.h"
/**
@brief PartArc::PartArc
Constructor
@@ -33,7 +31,8 @@
PartArc::PartArc(QETElementEditor *editor, QGraphicsItem *parent) :
AbstractPartEllipse(editor, parent)
{
setTagName("arc");
m_start_angle = 0;
m_span_angle = -1440;
}
/**
@@ -103,9 +102,9 @@ void PartArc::paint(QPainter *painter, const QStyleOptionGraphicsItem *options,
@param xml_document : Xml document to use for create the xml element.
@return : an xml element that describe this arc
*/
void PartArc::toXmlPriv(QDomElement& xml_element) const
const QDomElement PartArc::toXml(QDomDocument &xml_document) const
{
xml_element.setTagName("arc");
QDomElement xml_element = xml_document.createElement("arc");
QPointF top_left(sceneTopLeft());
xml_element.setAttribute("x", QString("%1").arg(top_left.x()));
xml_element.setAttribute("y", QString("%1").arg(top_left.y()));
@@ -115,6 +114,7 @@ void PartArc::toXmlPriv(QDomElement& xml_element) const
xml_element.setAttribute("start", QString("%1").arg(m_start_angle / 16));
xml_element.setAttribute("angle", QString("%1").arg(m_span_angle / 16));
stylesToXml(xml_element);
return(xml_element);
}
/**
@@ -122,41 +122,15 @@ void PartArc::toXmlPriv(QDomElement& xml_element) const
Import the properties of this arc from a xml element.
@param qde : Xml document to use.
*/
bool PartArc::fromXmlPriv(const QDomElement &qde) {
void PartArc::fromXml(const QDomElement &qde) {
stylesFromXml(qde);
m_rect = QRectF(mapFromScene(qde.attribute("x", "0").toDouble(),
qde.attribute("y", "0").toDouble()),
QSizeF(qde.attribute("width", "0").toDouble(),
qde.attribute("height", "0").toDouble()) );
double x=0, y=0, w=0, h=0;
if (QETXML::propertyDouble(qde, "x", &x) == QETXML::PropertyFlags::NoValidConversion ||
QETXML::propertyDouble(qde, "y", &y) == QETXML::PropertyFlags::NoValidConversion ||
QETXML::propertyDouble(qde, "width", &w) == QETXML::PropertyFlags::NoValidConversion ||
QETXML::propertyDouble(qde, "height", &h) == QETXML::PropertyFlags::NoValidConversion)
return false;
m_rect = QRectF(mapFromScene(x, y), QSizeF(w, h) );
m_start_angle = 0;
if (QETXML::propertyDouble(qde, "start", &m_start_angle) == QETXML::PropertyFlags::NoValidConversion)
return false;
m_start_angle *= 16;
m_span_angle = -1440;
if (QETXML::propertyDouble(qde, "angle", &m_span_angle) == QETXML::PropertyFlags::NoValidConversion)
return false;
m_span_angle *= 16;
return true;
}
bool PartArc::valideXml(QDomElement& element) {
if (QETXML::propertyDouble(element, "x") == QETXML::PropertyFlags::NoValidConversion ||
QETXML::propertyDouble(element, "y") == QETXML::PropertyFlags::NoValidConversion ||
QETXML::propertyDouble(element, "width") == QETXML::PropertyFlags::NoValidConversion ||
QETXML::propertyDouble(element, "height") == QETXML::PropertyFlags::NoValidConversion ||
QETXML::propertyDouble(element, "start") == QETXML::PropertyFlags::NoValidConversion ||
QETXML::propertyDouble(element, "angle") == QETXML::PropertyFlags::NoValidConversion)
return false;
return true;
m_start_angle = qde.attribute("start", "0").toDouble() * 16;
m_span_angle = qde.attribute("angle", "-1440").toDouble() * 16;
}
/**

7
sources/editor/graphicspart/partarc.h
View File

@@ -51,11 +51,8 @@ class PartArc : public AbstractPartEllipse
//Name and XML
QString name() const override { return(QObject::tr("arc", "element part name")); }
QString xmlName() const override { return(QString("arc")); }
void toXmlPriv(QDomElement&xml_element) const override;
bool fromXmlPriv (const QDomElement &) override;
static bool valideXml(QDomElement& element);
void toSettings(QSettings &,const QString & = QString()) const override {/*TODO: implement*/}
void fromSettings(QSettings &,const QString & = QString()) override{/*TODO: implement*/}
const QDomElement toXml (QDomDocument &) const override;
void fromXml (const QDomElement &) override;
QPainterPath shape() const override;
QPainterPath shadowShape() const override;

102
sources/editor/graphicspart/partdynamictextfield.cpp
View File

@@ -21,8 +21,6 @@
#include "../../qetapp.h"
#include "../elementscene.h"
#include "../../qetxml.h"
#include <QColor>
#include <QFont>
#include <QGraphicsSceneMouseEvent>
@@ -32,7 +30,6 @@ PartDynamicTextField::PartDynamicTextField(QETElementEditor *editor, QGraphicsIt
CustomElementPart(editor),
m_uuid(QUuid::createUuid())
{
setTagName(xmlName());
setDefaultTextColor(Qt::black);
setFont(QETApp::dynamicTextsItemFont());
QSettings settings;
@@ -96,8 +93,9 @@ void PartDynamicTextField::handleUserTransformation(
@param dom_doc
@return
*/
void PartDynamicTextField::toXmlPriv(QDomElement& root_element) const
const QDomElement PartDynamicTextField::toXml(QDomDocument &dom_doc) const
{
QDomElement root_element = dom_doc.createElement(xmlName());
root_element.setAttribute("x", QString::number(pos().x()));
root_element.setAttribute("y", QString::number(pos().y()));
@@ -126,61 +124,57 @@ void PartDynamicTextField::toXmlPriv(QDomElement& root_element) const
else if(this -> alignment() &Qt::AlignVCenter)
root_element.setAttribute("Valignment", me.valueToKey(Qt::AlignVCenter));
QDomElement dom_text = root_element.ownerDocument().createElement("text");
dom_text.appendChild(root_element.ownerDocument().createTextNode(toPlainText()));
QDomElement dom_text = dom_doc.createElement("text");
dom_text.appendChild(dom_doc.createTextNode(toPlainText()));
root_element.appendChild(dom_text);
//Info name
if(!m_info_name.isEmpty()) {
QDomElement dom_info_name = root_element.ownerDocument().createElement("info_name");
dom_info_name.appendChild(root_element.ownerDocument().createTextNode(m_info_name));
QDomElement dom_info_name = dom_doc.createElement("info_name");
dom_info_name.appendChild(dom_doc.createTextNode(m_info_name));
root_element.appendChild(dom_info_name);
}
//Composite text
if(!m_composite_text.isEmpty()) {
QDomElement dom_comp_text = root_element.ownerDocument().createElement("composite_text");
dom_comp_text.appendChild(root_element.ownerDocument().createTextNode(m_composite_text));
QDomElement dom_comp_text = dom_doc.createElement("composite_text");
dom_comp_text.appendChild(dom_doc.createTextNode(m_composite_text));
root_element.appendChild(dom_comp_text);
}
//Color
if(color() != QColor(Qt::black)) {
QDomElement dom_color = root_element.ownerDocument().createElement("color");
dom_color.appendChild(root_element.ownerDocument().createTextNode(color().name()));
QDomElement dom_color = dom_doc.createElement("color");
dom_color.appendChild(dom_doc.createTextNode(color().name()));
root_element.appendChild(dom_color);
}
return root_element;
}
/**
@brief PartDynamicTextField::fromXml
@param dom_elmt
*/
bool PartDynamicTextField::fromXmlPriv(const QDomElement &dom_elmt)
{
void PartDynamicTextField::fromXml(const QDomElement &dom_elmt) {
if (dom_elmt.tagName() != xmlName()) {
qDebug() << "PartDynamicTextField::fromXml : Wrong tagg name";
return false;
return;
}
double x=0, y=0, z=0, rot=0;
if (QETXML::propertyDouble(dom_elmt, "x", &x) == QETXML::PropertyFlags::NoValidConversion ||
QETXML::propertyDouble(dom_elmt, "y", &y) == QETXML::PropertyFlags::NoValidConversion ||
QETXML::propertyDouble(dom_elmt, "z", &z) == QETXML::PropertyFlags::NoValidConversion ||
QETXML::propertyDouble(dom_elmt, "rotation", &rot) == QETXML::PropertyFlags::NoValidConversion)
return false;
QGraphicsTextItem::setPos(
dom_elmt.attribute("x", QString::number(0)).toDouble(),
dom_elmt.attribute("y", QString::number(0)).toDouble()
);
setZValue(dom_elmt.attribute("z", QString::number(zValue())).toDouble());
QGraphicsTextItem::setRotation(dom_elmt.attribute("rotation", QString::number(0)).toDouble());
QGraphicsTextItem::setPos(x, y);
setZValue(z);
QGraphicsTextItem::setRotation(rot);
QString font;
if (QETXML::propertyString(dom_elmt, "font", &font) == QETXML::PropertyFlags::Success)
{
if (dom_elmt.hasAttribute("font")) {
QFont font_;
font_.fromString(font);
font_.fromString(dom_elmt.attribute("font"));
setFont(font_);
} else { //Keep compatibility TODO remove in futur
}
else {
#if TODO_LIST
#pragma message("@TODO remove in futur")
#endif
@@ -188,24 +182,19 @@ bool PartDynamicTextField::fromXmlPriv(const QDomElement &dom_elmt)
setFont(QETApp::dynamicTextsItemFont(9));
}
QETXML::propertyUuid(dom_elmt, "uuid", &m_uuid);
bool frame;
QETXML::propertyBool(dom_elmt, "frame", &frame);
double text_width=-1;
QETXML::propertyDouble(dom_elmt, "text_width", &text_width);
setTextWidth(text_width);
m_uuid = QUuid(dom_elmt.attribute("uuid", QUuid::createUuid().toString()));
setFrame(dom_elmt.attribute("frame", "false") == "true"? true : false);
setTextWidth(dom_elmt.attribute("text_width", QString::number(-1)).toDouble());
QMetaEnum me = DynamicElementTextItem::textFromMetaEnum();
QString text_from;
QETXML::propertyString(dom_elmt, "text_from", &text_from);
m_text_from = DynamicElementTextItem::TextFrom(me.keyToValue(text_from.toStdString().data()));
m_text_from = DynamicElementTextItem::TextFrom(
me.keyToValue(dom_elmt.attribute("text_from").toStdString().data()));
me = QMetaEnum::fromType<Qt::Alignment>();
QString alignment;
if(QETXML::propertyString(dom_elmt, "Halignment", &alignment) != QETXML::PropertyFlags::NotFound)
setAlignment(Qt::Alignment(me.keyToValue(alignment.toStdString().data())));
if(QETXML::propertyString(dom_elmt, "Valignment", &alignment) != QETXML::PropertyFlags::NotFound)
if(dom_elmt.hasAttribute("Halignment"))
setAlignment(Qt::Alignment(
me.keyToValue(dom_elmt.attribute("Halignment").toStdString().data())));
if(dom_elmt.hasAttribute(("Valignment")))
setAlignment(Qt::Alignment(
me.keyToValue(dom_elmt.attribute("Valignment").toStdString().data())) | this -> alignment());
@@ -232,29 +221,6 @@ bool PartDynamicTextField::fromXmlPriv(const QDomElement &dom_elmt)
QDomElement dom_color = dom_elmt.firstChildElement("color");
if(!dom_color.isNull())
setColor(QColor(dom_color.text()));
return true;
}
bool PartDynamicTextField::valideXml(QDomElement& dom_elmt) {
if (QETXML::propertyDouble(dom_elmt, "x") == QETXML::PropertyFlags::NoValidConversion ||
QETXML::propertyDouble(dom_elmt, "y") == QETXML::PropertyFlags::NoValidConversion ||
QETXML::propertyDouble(dom_elmt, "z") == QETXML::PropertyFlags::NoValidConversion ||
QETXML::propertyDouble(dom_elmt, "rotation") == QETXML::PropertyFlags::NoValidConversion)
return false;
if (QETXML::propertyUuid(dom_elmt, "uuid") == QETXML::PropertyFlags::NoValidConversion)
return false;
if (QETXML::propertyString(dom_elmt, "text_from"))
return false;
if(QETXML::propertyString(dom_elmt, "Halignment") == QETXML::PropertyFlags::NotFound)
return false;
if(QETXML::propertyString(dom_elmt, "Valignment") == QETXML::PropertyFlags::NotFound)
return false;
return true;
}
/**
@@ -498,7 +464,7 @@ void PartDynamicTextField::mouseReleaseEvent(QGraphicsSceneMouseEvent *event) {
m_origine_pos != pos()) {
QPropertyUndoCommand *undo =\
new QPropertyUndoCommand(this, "pos", QVariant(m_origine_pos), QVariant(pos()));
undo -> setText(tr("D??placer un champ texte"));
undo -> setText(tr("Déplacer un champ texte"));
undo -> enableAnimation();
elementScene() -> undoStack().push(undo);
}

9
sources/editor/graphicspart/partdynamictextfield.h
View File

@@ -75,12 +75,9 @@ class PartDynamicTextField : public QGraphicsTextItem, public CustomElementPart
void startUserTransformation(const QRectF &initial_selection_rect) override;
void handleUserTransformation(const QRectF &initial_selection_rect, const QRectF &new_selection_rect) override;
void toXmlPriv(QDomElement&root_element) const override;
bool fromXmlPriv(const QDomElement &dom_elmt) override;
const QDomElement toXml(QDomDocument &dom_doc) const override;
void fromXml(const QDomElement &dom_elmt) override;
void fromTextFieldXml(const QDomElement &dom_element);
static bool valideXml(QDomElement& dom_elmt);
void toSettings(QSettings &,const QString & = QString()) const override {/*TODO: implement*/}
void fromSettings(QSettings &,const QString & = QString()) override{/*TODO: implement*/}
DynamicElementTextItem::TextFrom textFrom() const;
void setTextFrom (DynamicElementTextItem::TextFrom text_from);
@@ -119,7 +116,7 @@ class PartDynamicTextField : public QGraphicsTextItem, public CustomElementPart
m_info_name,
m_composite_text;
DynamicElementTextItem::TextFrom m_text_from = DynamicElementTextItem::UserText;
QUuid m_uuid{QUuid::createUuid()};
QUuid m_uuid;
bool m_frame = false,
m_first_add = true,
m_block_alignment = false;

63
sources/editor/graphicspart/partellipse.cpp
View File

@@ -22,8 +22,6 @@
#include "../../QetGraphicsItemModeler/qetgraphicshandlerutility.h"
#include "../elementscene.h"
#include "../../qetxml.h"
/**
@brief PartEllipse::PartEllipse
Constructor
@@ -81,20 +79,22 @@ void PartEllipse::paint(QPainter *painter, const QStyleOptionGraphicsItem *optio
}
/**
@brief PartEllipse::toXmlPriv
@brief PartEllipse::toXml
Export this ellipse in xml
@param xml_document : Xml document to use for create the xml element.
@return : an xml element that describe this ellipse
*/
void PartEllipse::toXmlPriv(QDomElement& xml_element) const
const QDomElement PartEllipse::toXml(QDomDocument &xml_document) const
{
QDomElement xml_element;
if (qFuzzyCompare(rect().width(), rect().height()))
{
xml_element.setTagName("circle");
xml_element = xml_document.createElement("circle");
xml_element.setAttribute("diameter", QString("%1").arg(rect().width()));
}
else
{
xml_element.setTagName("ellipse");
xml_element = xml_document.createElement("ellipse");
xml_element.setAttribute("width", QString("%1").arg(rect().width()));
xml_element.setAttribute("height", QString("%1").arg(rect().height()));
}
@@ -104,58 +104,31 @@ void PartEllipse::toXmlPriv(QDomElement& xml_element) const
xml_element.setAttribute("y", QString("%1").arg(top_left.y()));
stylesToXml(xml_element);
return(xml_element);
}
/**
@brief PartEllipse::fromXmlPriv
@brief PartEllipse::fromXml
Import the properties of this ellipse from a xml element.
@param qde : Xml document to use.
*/
bool PartEllipse::fromXmlPriv(const QDomElement &qde)
void PartEllipse::fromXml(const QDomElement &qde)
{
stylesFromXml(qde);
double x=0, y=0, width=0, height=0;
qreal width, height;
if (qde.tagName() == "ellipse")
{
if (QETXML::propertyDouble(qde, "width", &width) == QETXML::PropertyFlags::NoValidConversion ||
QETXML::propertyDouble(qde, "height", &height) == QETXML::PropertyFlags::NoValidConversion)
return false;
}
else {
if (QETXML::propertyDouble(qde, "diameter", &width) == QETXML::PropertyFlags::NoValidConversion)
return false;
height = width;
width = qde.attribute("width", "0").toDouble();
height = qde.attribute("height", "0").toDouble();
}
else
width = height = qde.attribute("diameter", "0").toDouble();
if (QETXML::propertyDouble(qde, "x", &x) == QETXML::PropertyFlags::NoValidConversion ||
QETXML::propertyDouble(qde, "y", &y) == QETXML::PropertyFlags::NoValidConversion)
return false;
m_rect = QRectF(mapFromScene(x, y), QSizeF(width, height));
return true;
}
bool PartEllipse::valideXml(QDomElement& element) {
if (element.tagName() == "ellipse")
{
if (QETXML::propertyDouble(element, "width") & QETXML::PropertyFlags::NoValidConversion ||
QETXML::propertyDouble(element, "height") & QETXML::PropertyFlags::NoValidConversion)
return false;
}
else {
if (QETXML::propertyDouble(element, "diameter") & QETXML::PropertyFlags::NoValidConversion)
return false;
}
if ((QETXML::propertyDouble(element, "x") & QETXML::PropertyFlags::NoValidConversion) ||
(QETXML::propertyDouble(element, "y") & QETXML::PropertyFlags::NoValidConversion))
return false;
return true;
m_rect = QRectF(mapFromScene(qde.attribute("x", "0").toDouble(),
qde.attribute("y", "0").toDouble()),
QSizeF(width, height));
}
/**

7
sources/editor/graphicspart/partellipse.h
View File

@@ -52,11 +52,8 @@ class PartEllipse : public AbstractPartEllipse
//Name and XML
QString name() const override { return(QObject::tr("ellipse", "element part name")); }
QString xmlName() const override { return(QString("ellipse")); }
void toXmlPriv(QDomElement&xml_element) const override;
bool fromXmlPriv(const QDomElement &) override;
static bool valideXml(QDomElement& element);
void toSettings(QSettings &,const QString & = QString()) const override {/*TODO: implement*/}
void fromSettings(QSettings &,const QString & = QString()) override{/*TODO: implement*/}
const QDomElement toXml (QDomDocument &) const override;
void fromXml (const QDomElement &) override;
QPainterPath shape() const override;
QPainterPath shadowShape() const override;
void setRect(const QRectF &rect) override {AbstractPartEllipse::setRect(rect); adjusteHandlerPos();}

68
sources/editor/graphicspart/partline.cpp
View File

@@ -21,8 +21,6 @@
#include "../../QetGraphicsItemModeler/qetgraphicshandleritem.h"
#include "../elementscene.h"
#include "../../qetxml.h"
#include <cmath>
/**
@@ -32,10 +30,13 @@
@param parent : parent item
*/
PartLine::PartLine(QETElementEditor *editor, QGraphicsItem *parent) :
CustomElementGraphicPart(editor, parent)
{
setTagName("line");
}
CustomElementGraphicPart(editor, parent),
first_end(Qet::None),
first_length(1.5),
second_end(Qet::None),
second_length(1.5),
m_undo_command(nullptr)
{}
/// Destructeur
PartLine::~PartLine()
@@ -104,16 +105,17 @@ void PartLine::paint(QPainter *painter, const QStyleOptionGraphicsItem *options,
}
/**
@brief PartLine::toXmlPriv
@brief PartLine::toXml
Export this line in xml
@param xml_document : Xml document to use for create the xml element.
@return an xml element that describe this line
*/
void PartLine::toXmlPriv(QDomElement& xml_element) const
const QDomElement PartLine::toXml(QDomDocument &xml_document) const
{
QPointF p1(sceneP1());
QPointF p2(sceneP2());
QDomElement xml_element = xml_document.createElement("line");
xml_element.setAttribute("x1", QString("%1").arg(p1.x()));
xml_element.setAttribute("y1", QString("%1").arg(p1.y()));
xml_element.setAttribute("x2", QString("%1").arg(p2.x()));
@@ -124,6 +126,7 @@ void PartLine::toXmlPriv(QDomElement& xml_element) const
xml_element.setAttribute("length2", QString("%1").arg(second_length));
stylesToXml(xml_element);
return(xml_element);
}
/**
@@ -131,48 +134,17 @@ void PartLine::toXmlPriv(QDomElement& xml_element) const
Import the properties of this line from a xml element.
@param qde : Xml document to use
*/
bool PartLine::fromXmlPriv(const QDomElement &qde) {
void PartLine::fromXml(const QDomElement &qde) {
stylesFromXml(qde);
m_line = QLineF(mapFromScene(qde.attribute("x1", "0").toDouble(),
qde.attribute("y1", "0").toDouble()),
mapFromScene(qde.attribute("x2", "0").toDouble(),
qde.attribute("y2", "0").toDouble()));
double x1 = 0, y1 = 0, x2 = 0, y2 = 0;
if (QETXML::propertyDouble(qde, "x1", &x1) == QETXML::PropertyFlags::NoValidConversion ||
QETXML::propertyDouble(qde, "y1", &y1) == QETXML::PropertyFlags::NoValidConversion ||
QETXML::propertyDouble(qde, "x2", &x2) == QETXML::PropertyFlags::NoValidConversion ||
QETXML::propertyDouble(qde, "y2", &y2) == QETXML::PropertyFlags::NoValidConversion)
return false;
m_line = QLineF(mapFromScene(x1, y1),
mapFromScene(x2, y2));
QString s;
if (QETXML::propertyString(qde, "end1", &s) != QETXML::PropertyFlags::Success)
return false;
first_end = Qet::endTypeFromString(s);
if (QETXML::propertyString(qde, "end2", &s) != QETXML::PropertyFlags::Success)
return false;
first_end = Qet::endTypeFromString(s);
if (QETXML::propertyDouble(qde, "length1", &first_length) == QETXML::PropertyFlags::NoValidConversion ||
QETXML::propertyDouble(qde, "length2", &second_length) == QETXML::PropertyFlags::NoValidConversion)
return false;
return true;
}
bool PartLine::valideXml(QDomElement& element) const {
if (QETXML::propertyDouble(element, "x1") ||
QETXML::propertyDouble(element, "y1") ||
QETXML::propertyDouble(element, "x2") ||
QETXML::propertyDouble(element, "y2") ||
QETXML::propertyString(element, "end1") ||
QETXML::propertyString(element, "end2") ||
QETXML::propertyDouble(element, "length1") ||
QETXML::propertyDouble(element, "length2") )
return false;
return true;
first_end = Qet::endTypeFromString(qde.attribute("end1"));
first_length = qde.attribute("length1", "1.5").toDouble();
second_end = Qet::endTypeFromString(qde.attribute("end2"));
second_length = qde.attribute("length2", "1.5").toDouble();
}
/**

17
sources/editor/graphicspart/partline.h
View File

@@ -70,11 +70,8 @@ class PartLine : public CustomElementGraphicPart
void paint(QPainter *, const QStyleOptionGraphicsItem *, QWidget * = nullptr) override;
QString name() const override { return(QObject::tr("ligne", "element part name")); }
QString xmlName() const override { return(QString("line")); }
void toXmlPriv(QDomElement&xml_element) const override;
bool fromXmlPriv(const QDomElement &) override;
bool valideXml(QDomElement& element) const;
void toSettings(QSettings &,const QString & = QString()) const override {/*TODO: implement*/}
void fromSettings(QSettings &,const QString & = QString()) override{/*TODO: implement*/}
const QDomElement toXml(QDomDocument &) const override;
void fromXml(const QDomElement &) override;
virtual QPointF sceneP1() const;
virtual QPointF sceneP2() const;
QPainterPath shape() const override;
@@ -117,15 +114,15 @@ class PartLine : public CustomElementGraphicPart
QRectF secondEndCircleRect() const;
/*****************/
Qet::EndType first_end{Qet::EndType::None};
qreal first_length{1.5};
Qet::EndType first_end;
qreal first_length;
Qet::EndType second_end{Qet::EndType::None};
qreal second_length{1.5};
Qet::EndType second_end;
qreal second_length;
QList<QPointF> saved_points_;
QLineF m_line;
int m_vector_index = -1;
QPropertyUndoCommand *m_undo_command{nullptr};
QPropertyUndoCommand *m_undo_command;
QVector<QetGraphicsHandlerItem *> m_handler_vector;
};
#endif

41
sources/editor/graphicspart/partpolygon.cpp
View File

@@ -24,8 +24,6 @@
#include "../elementscene.h"
#include "../ui/qetelementeditor.h"
#include "../../qetxml.h"
/**
@brief PartPolygon::PartPolygon
Constructor
@@ -37,7 +35,6 @@ PartPolygon::PartPolygon(QETElementEditor *editor, QGraphicsItem *parent) :
m_closed(false),
m_undo_command(nullptr)
{
setTagName("polygon");
m_insert_point = new QAction(tr("Ajouter un point"), this);
m_insert_point->setIcon(QET::Icons::Add);
connect(m_insert_point, &QAction::triggered, this, &PartPolygon::insertPoint);
@@ -92,46 +89,40 @@ void PartPolygon::paint(QPainter *painter, const QStyleOptionGraphicsItem *optio
Import the properties of this polygon from a xml element
@param qde : Xml document to use
*/
bool PartPolygon::fromXmlPriv(const QDomElement &qde)
void PartPolygon::fromXml(const QDomElement &qde)
{
stylesFromXml(qde);
int error_counter = 0;
int i = 1;
while(true)
{
if (QETXML::propertyDouble(qde, QString("x%1").arg(i)) == QETXML::PropertyFlags::Success &&
QETXML::propertyDouble(qde, QString("y%1").arg(i)) == QETXML::PropertyFlags::Success)
i++;
if (QET::attributeIsAReal(qde, QString("x%1").arg(i)) &&\
QET::attributeIsAReal(qde, QString("y%1").arg(i)))
++ i;
else break;
}
QPolygonF temp_polygon;
double x, y;
for (int j = 1 ; j < i ; ++ j)
{
error_counter += QETXML::propertyDouble(qde, QString("x%1").arg(j), &x);
error_counter += QETXML::propertyDouble(qde, QString("y%1").arg(j), &y);
if (error_counter)
return false;
temp_polygon << QPointF(x, y);
temp_polygon << QPointF(qde.attribute(QString("x%1").arg(j)).toDouble(),
qde.attribute(QString("y%1").arg(j)).toDouble());
}
m_polygon = temp_polygon;
if (QETXML::propertyBool(qde, "closed", &m_closed) != QETXML::PropertyFlags::Success)
return false;
return true;
m_closed = qde.attribute("closed") != "false";
}
/**
@brief PartPolygon::toXmlPriv
@brief PartPolygon::toXml
Export this polygin in xml
@param e: properties get part of this DomElement
@param xml_document : Xml document to use for create the xml element
@return an xml element that describe this polygon
*/
void PartPolygon::toXmlPriv(QDomElement& xml_element) const
const QDomElement PartPolygon::toXml(QDomDocument &xml_document) const
{
QDomElement xml_element = xml_document.createElement("polygon");
int i = 1;
foreach(QPointF point, m_polygon) {
point = mapToScene(point);
@@ -141,11 +132,7 @@ void PartPolygon::toXmlPriv(QDomElement& xml_element) const
}
if (!m_closed) xml_element.setAttribute("closed", "false");
stylesToXml(xml_element);
}
bool PartPolygon::valideXml(QDomElement& element) {
// TODO: implement
return true;
return(xml_element);
}
/**
@@ -538,7 +525,7 @@ void PartPolygon::insertPoint()
if(new_polygon != m_polygon)
{
//Wrap the undo for avoid to merge the undo commands when user add several points.
QUndoCommand *undo = new QUndoCommand(tr("Ajouter un point ?? un polygone"));
QUndoCommand *undo = new QUndoCommand(tr("Ajouter un point à un polygone"));
new QPropertyUndoCommand(this, "polygon", m_polygon, new_polygon, undo);
elementScene()->undoStack().push(undo);
}

10
sources/editor/graphicspart/partpolygon.h
View File

@@ -61,12 +61,8 @@ class PartPolygon : public CustomElementGraphicPart
QString name() const override { return(QObject::tr("polygone", "element part name")); }
QString xmlName() const override { return(QString("polygon")); }
bool fromXmlPriv(const QDomElement &) override;
void toXmlPriv(QDomElement&xml_element) const override;
static bool valideXml(QDomElement& element);
void toSettings(QSettings &,const QString & = QString()) const override {/*TODO: implement*/}
void fromSettings(QSettings &,const QString & = QString()) override{/*TODO: implement*/}
void fromXml(const QDomElement &) override;
const QDomElement toXml(QDomDocument &) const override;
QPainterPath shape () const override;
QPainterPath shadowShape() const override;
@@ -109,7 +105,7 @@ class PartPolygon : public CustomElementGraphicPart
void removePoint();
bool m_closed{false};
bool m_closed;
QList<QPointF> saved_points_;
QPolygonF m_polygon;
QPropertyUndoCommand *m_undo_command;

53
sources/editor/graphicspart/partrectangle.cpp
View File

@@ -22,8 +22,6 @@
#include "../../QetGraphicsItemModeler/qetgraphicshandlerutility.h"
#include "../elementscene.h"
#include "../../qetxml.h"
/**
@brief PartRectangle::PartRectangle
Constructor
@@ -32,9 +30,7 @@
*/
PartRectangle::PartRectangle(QETElementEditor *editor, QGraphicsItem *parent) :
CustomElementGraphicPart(editor, parent)
{
setTagName("rect");
}
{}
/**
@brief PartRectangle::~PartRectangle
@@ -84,13 +80,14 @@ void PartRectangle::paint(QPainter *painter, const QStyleOptionGraphicsItem *opt
}
/**
@brief PartRectangle::toXmlPriv
@brief PartRectangle::toXml
Export this rectangle in xml
@param xml_document : Xml document to use for create the xml element.
@return an xml element that describe this ellipse
*/
void PartRectangle::toXmlPriv(QDomElement& xml_element) const
const QDomElement PartRectangle::toXml(QDomDocument &xml_document) const
{
QDomElement xml_element = xml_document.createElement("rect");
QPointF top_left(sceneTopLeft());
xml_element.setAttribute("x", QString("%1").arg(top_left.x()));
xml_element.setAttribute("y", QString("%1").arg(top_left.y()));
@@ -111,6 +108,7 @@ void PartRectangle::toXmlPriv(QDomElement& xml_element) const
xml_element.setAttribute("ry", QString::number(m_yRadius));
stylesToXml(xml_element);
return(xml_element);
}
/**
@@ -118,45 +116,18 @@ void PartRectangle::toXmlPriv(QDomElement& xml_element) const
Import the properties of this rectangle from a xml element.
@param qde : Xml document to use.
*/
bool PartRectangle::fromXmlPriv(const QDomElement &qde)
void PartRectangle::fromXml(const QDomElement &qde)
{
stylesFromXml(qde);
setPos(mapFromScene(qde.attribute("x", "0").toDouble(),
qde.attribute("y", "0").toDouble()));
double x=0, y=0, w=0, h=0, rx=0, ry=0;
if (QETXML::propertyDouble(qde, "x", &x) == QETXML::PropertyFlags::NoValidConversion ||
QETXML::propertyDouble(qde, "y", &y) == QETXML::PropertyFlags::NoValidConversion)
return false;
setPos(mapFromScene(x, y));
if (QETXML::propertyDouble(qde, "width", &w) == QETXML::PropertyFlags::NoValidConversion ||
QETXML::propertyDouble(qde, "height", &h) == QETXML::PropertyFlags::NoValidConversion)
return false;
QRectF rect(QPointF(0,0), QSizeF(w, h));
QRectF rect(QPointF(0,0), QSizeF(qde.attribute("width", "0").toDouble(),
qde.attribute("height", "0").toDouble()));
setRect(rect.normalized());
if (QETXML::propertyDouble(qde, "rx", &rx) == QETXML::PropertyFlags::NoValidConversion ||
QETXML::propertyDouble(qde, "ry", &ry) == QETXML::PropertyFlags::NoValidConversion)
return false;
setXRadius(rx);
setYRadius(ry);
return true;
}
bool PartRectangle::valideXml(QDomElement& element) {
// parameters have default values so no value is not a non valid xml element
if ((QETXML::propertyDouble(element, "x") & QETXML::PropertyFlags::NoValidConversion) |
(QETXML::propertyDouble(element, "y") & QETXML::PropertyFlags::NoValidConversion) |
(QETXML::propertyDouble(element, "width") & QETXML::PropertyFlags::NoValidConversion) |
(QETXML::propertyDouble(element, "height") & QETXML::PropertyFlags::NoValidConversion) |
(QETXML::propertyDouble(element, "rx") & QETXML::PropertyFlags::NoValidConversion) |
(QETXML::propertyDouble(element, "ry") & QETXML::PropertyFlags::NoValidConversion))
return false;
return true;
setXRadius(qde.attribute("rx", "0").toDouble());
setYRadius(qde.attribute("ry", "0").toDouble());
}
/**

7
sources/editor/graphicspart/partrectangle.h
View File

@@ -60,11 +60,8 @@ class PartRectangle : public CustomElementGraphicPart
QString name () const override { return(QObject::tr("rectangle", "element part name")); }
QString xmlName () const override { return(QString("rect")); }
void toXmlPriv(QDomElement&xml_element) const override;
bool fromXmlPriv (const QDomElement &) override;
static bool valideXml(QDomElement& element);
void toSettings(QSettings &,const QString & = QString()) const override {/*TODO: implement*/}
void fromSettings(QSettings &,const QString & = QString()) override{/*TODO: implement*/}
const QDomElement toXml (QDomDocument &) const override;
void fromXml (const QDomElement &) override;
QRectF rect() const;
void setRect(const QRectF &rect);

38
sources/editor/graphicspart/partterminal.cpp
View File

@@ -19,8 +19,6 @@
#include "../../qetgraphicsitem/terminal.h"
#include "../../qetxml.h"
/**
@brief PartTerminal::PartTerminal
@param editor :
@@ -31,9 +29,7 @@
PartTerminal::PartTerminal(QETElementEditor *editor, QGraphicsItem *parent) :
CustomElementGraphicPart(editor, parent)
{
setTagName("terminal");
d = new TerminalData(this);
d->m_name = tr("terminal");
d -> m_orientation = Qet::North;
d -> m_uuid = QUuid::createUuid(); // if part is loaded this uuid will be overwritten, but being sure that terminal has a uuid
updateSecondPoint();
@@ -49,20 +45,10 @@ PartTerminal::~PartTerminal()
Importe les proprietes d'une borne depuis un element XML
@param xml_elmt Element XML a lire
*/
bool PartTerminal::fromXmlPriv(const QDomElement &xml_elmt) {
// update part and add uuid, which is used in the new version to connect terminals together
// if the attribute not exists, means, the element is created with an older version of qet. So use the legacy approach
// to identify terminals
QETXML::propertyUuid(xml_elmt, "uuid", &d->m_uuid);
if (!d->fromXml(xml_elmt))
return false;
void PartTerminal::fromXml(const QDomElement &xml_elmt) {
d -> fromXml(xml_elmt);
setPos(d -> m_pos);
updateSecondPoint();
return true;
}
/**
@@ -70,19 +56,9 @@ bool PartTerminal::fromXmlPriv(const QDomElement &xml_elmt) {
@param xml_document Document XML a utiliser pour creer l'element XML
@return un element XML decrivant la borne
*/
void PartTerminal::toXmlPriv(QDomElement& e) const {
e.setAttribute("uuid", d->m_uuid.toString());
d->m_pos = pos();
QDomDocument doc = e.ownerDocument();
e.appendChild(d -> toXml(doc));
}
bool PartTerminal::valideXml(QDomElement& element) {
return TerminalData::valideXml(element);
const QDomElement PartTerminal::toXml(QDomDocument &xml_document) const
{
return d -> toXml(xml_document);
}
/**
@@ -247,7 +223,7 @@ QRectF PartTerminal::sceneGeometricRect() const
*/
void PartTerminal::startUserTransformation(const QRectF &initial_selection_rect) {
Q_UNUSED(initial_selection_rect)
m_saved_position = scenePos();
saved_position_ = scenePos();
}
/**
@@ -255,6 +231,6 @@ void PartTerminal::startUserTransformation(const QRectF &initial_selection_rect)
*/
void PartTerminal::handleUserTransformation(const QRectF &initial_selection_rect, const QRectF &new_selection_rect) {
QPointF mapped_point = mapPoints(
initial_selection_rect, new_selection_rect, QList<QPointF>() << m_saved_position).first();
initial_selection_rect, new_selection_rect, QList<QPointF>() << saved_position_).first();
setPos(mapped_point);
}

11
sources/editor/graphicspart/partterminal.h
View File

@@ -56,11 +56,8 @@ class PartTerminal : public CustomElementGraphicPart
*/
int type() const override { return Type; }
QString xmlName() const override { return(QString("terminal")); }
bool fromXmlPriv(const QDomElement &) override;
void toXmlPriv(QDomElement&xml_element) const override;
static bool valideXml(QDomElement& element);
void toSettings(QSettings &,const QString & = QString()) const override {/*TODO: implement*/}
void fromSettings(QSettings &,const QString & = QString()) override{/*TODO: implement*/}
void fromXml(const QDomElement &) override;
const QDomElement toXml(QDomDocument &) const override;
void paint(
QPainter *painter,
const QStyleOptionGraphicsItem *,
@@ -87,9 +84,9 @@ class PartTerminal : public CustomElementGraphicPart
private:
void updateSecondPoint();
TerminalData* d{nullptr}; // pointer to the terminal data
TerminalData* d; // pointer to the terminal data
private:
QPointF m_saved_position;
QPointF saved_position_;
};
#endif

78
sources/editor/graphicspart/parttext.cpp
View File

@@ -23,8 +23,6 @@
#include "../elementscene.h"
#include "../ui/texteditor.h"
#include "../../qetxml.h"
/**
Constructeur
@param editor L'editeur d'element concerne
@@ -69,49 +67,29 @@ PartText::~PartText()
Importe les proprietes d'un texte statique depuis un element XML
@param xml_element Element XML a lire
*/
bool PartText::fromXmlPriv(const QDomElement &xml_element)
{
int size;
QString font;
void PartText::fromXml(const QDomElement &xml_element) {
bool ok;
if (QETXML::propertyInteger(xml_element, "size", &size) != QETXML::PropertyFlags::NotFound)
{
if (size < 1) {
size = 20;
if (xml_element.hasAttribute("size")) {
int font_size = xml_element.attribute("size").toInt(&ok);
if (!ok || font_size < 1) {
font_size = 20;
}
QFont font_ = this -> font();
font_.setPointSize(size);
font_.setPointSize(font_size);
setFont(font_);
}
else if (QETXML::propertyString(xml_element, "font", &font) != QETXML::PropertyFlags::NotFound)
{
else if (xml_element.hasAttribute("font")) {
QFont font_;
font_.fromString(font);
font_.fromString(xml_element.attribute("font"));
setFont(font_);
} else {
return false;
}
QColor color;
QString text;
QETXML::propertyColor(xml_element, "color", &color);
setDefaultTextColor(color);
QETXML::propertyString(xml_element, "text", &text);
setPlainText(text);
double x=0, y=0, rot=0;
if (QETXML::propertyDouble(xml_element, "x", &x) == QETXML::PropertyFlags::NoValidConversion ||
QETXML::propertyDouble(xml_element, "y", &y) == QETXML::PropertyFlags::NoValidConversion)
return false;
setPos(x, y);
if (QETXML::propertyDouble(xml_element, "rotation", &rot) == QETXML::PropertyFlags::NoValidConversion)
return false;
setRotation(rot);
return true;
setDefaultTextColor(QColor(xml_element.attribute("color", "#000000")));
setPlainText(xml_element.attribute("text"));
setPos(xml_element.attribute("x").toDouble(),
xml_element.attribute("y").toDouble());
setRotation(xml_element.attribute("rotation", QString::number(0)).toDouble());
}
/**
@@ -119,38 +97,18 @@ bool PartText::fromXmlPriv(const QDomElement &xml_element)
@param xml_document Document XML a utiliser pour creer l'element XML
@return un element XML decrivant le texte statique
*/
void PartText::toXmlPriv(QDomElement& xml_element) const
const QDomElement PartText::toXml(QDomDocument &xml_document) const
{
QDomElement xml_element = xml_document.createElement(xmlName());
xml_element.setAttribute("x", QString::number(pos().x()));
xml_element.setAttribute("y", QString::number(pos().y()));
xml_element.setAttribute("text", toPlainText());
xml_element.setAttribute("font", font().toString());
xml_element.setAttribute("rotation", QString::number(rotation()));
xml_element.setAttribute("color", defaultTextColor().name());
}
bool PartText::valideXml(QDomElement& element) {
if (QETXML::propertyInteger(element, "size") == QETXML::PropertyFlags::NotFound ||
QETXML::propertyString(element, "font") == QETXML::PropertyFlags::NotFound) {
return false;
}
if (QETXML::propertyString(element, "color") == QETXML::PropertyFlags::NoValidConversion)
return false;
if (QETXML::propertyString(element, "text"))
return false;
if (QETXML::propertyDouble(element, "x") == QETXML::PropertyFlags::NoValidConversion ||
QETXML::propertyDouble(element, "y") == QETXML::PropertyFlags::NoValidConversion)
return false;
if (QETXML::propertyDouble(element, "rotation", 0) == QETXML::PropertyFlags::NoValidConversion)
return false;
return true;
return(xml_element);
}
/**

7
sources/editor/graphicspart/parttext.h
View File

@@ -59,11 +59,8 @@ class PartText : public QGraphicsTextItem, public CustomElementPart {
int type() const override { return Type; }
QString name() const override { return(QObject::tr("texte", "element part name")); }
QString xmlName() const override { return(QString("text")); }
bool fromXmlPriv(const QDomElement &) override;
static bool valideXml(QDomElement& element);
void toSettings(QSettings &,const QString & = QString()) const override {/*TODO: implement*/}
void fromSettings(QSettings &,const QString & = QString()) override{/*TODO: implement*/}
void toXmlPriv(QDomElement&xml_element) const override;
void fromXml(const QDomElement &) override;
const QDomElement toXml(QDomDocument &) const override;
void setRotation(qreal angle) {(QGraphicsObject::setRotation(QET::correctAngle(angle)));}
bool isUseless() const override;
QRectF sceneGeometricRect() const override;

4
sources/editor/styleeditor.cpp
View File

@@ -440,10 +440,10 @@ void StyleEditor::updatePartFilling()
}
/**
@brief StyleEditor::updateFormPriv
@brief StyleEditor::updateForm
Update the edition form according to the value of edited part(s)
*/
void StyleEditor::updateFormPriv()
void StyleEditor::updateForm()
{
if (!part && m_part_list.isEmpty()) return;
activeConnections(false);

2
sources/editor/styleeditor.h
View File

@@ -60,7 +60,7 @@ class StyleEditor : public ElementItemEditor
static bool isStyleEditable (QList <CustomElementPart *> cep_list);
public slots:
void updateFormPriv() override;
void updateForm() override;
void updatePartAntialiasing();
void updatePartColor();
void updatePartLineStyle();

34
sources/editor/ui/dynamictextfieldeditor.cpp
View File

@@ -51,8 +51,8 @@ DynamicTextFieldEditor::DynamicTextFieldEditor(QETElementEditor *editor,
DynamicTextFieldEditor::~DynamicTextFieldEditor()
{
delete ui;
if(!m_change_connections.isEmpty()) {
for(const QMetaObject::Connection& con : m_change_connections) {
if(!m_connection_list.isEmpty()) {
for(const QMetaObject::Connection& con : m_connection_list) {
disconnect(con);
}
}
@@ -130,7 +130,7 @@ QList<CustomElementPart*> DynamicTextFieldEditor::currentParts() const
return parts;
}
void DynamicTextFieldEditor::updateFormPriv()
void DynamicTextFieldEditor::updateForm()
{
if(m_text_field) {
ui -> m_x_sb -> setValue(m_text_field.data() -> x());
@@ -182,38 +182,38 @@ void DynamicTextFieldEditor::setupWidget()
void DynamicTextFieldEditor::setUpConnections()
{
assert(m_change_connections.isEmpty());
assert(m_connection_list.isEmpty());
//Setup the connection
m_change_connections << connect(m_text_field.data(), &PartDynamicTextField::colorChanged,
m_connection_list << connect(m_text_field.data(), &PartDynamicTextField::colorChanged,
[this](){this -> updateForm();});
m_change_connections << connect(m_text_field.data(), &PartDynamicTextField::fontChanged,
m_connection_list << connect(m_text_field.data(), &PartDynamicTextField::fontChanged,
[this](){this -> updateForm();});
m_change_connections << connect(m_text_field.data(), &PartDynamicTextField::taggChanged,
m_connection_list << connect(m_text_field.data(), &PartDynamicTextField::taggChanged,
[this](){this -> updateForm();});
m_change_connections << connect(m_text_field.data(), &PartDynamicTextField::textFromChanged,
m_connection_list << connect(m_text_field.data(), &PartDynamicTextField::textFromChanged,
[this](){this -> updateForm();});
m_change_connections << connect(m_text_field.data(), &PartDynamicTextField::textChanged,
m_connection_list << connect(m_text_field.data(), &PartDynamicTextField::textChanged,
[this](){this -> updateForm();});
m_change_connections << connect(m_text_field.data(), &PartDynamicTextField::infoNameChanged,
m_connection_list << connect(m_text_field.data(), &PartDynamicTextField::infoNameChanged,
[this](){this -> updateForm();});
m_change_connections << connect(m_text_field.data(), &PartDynamicTextField::rotationChanged,
m_connection_list << connect(m_text_field.data(), &PartDynamicTextField::rotationChanged,
[this](){this -> updateForm();});
m_change_connections << connect(m_text_field.data(), &PartDynamicTextField::frameChanged,
m_connection_list << connect(m_text_field.data(), &PartDynamicTextField::frameChanged,
[this](){this -> updateForm();});
m_change_connections << connect(m_text_field.data(), &PartDynamicTextField::textWidthChanged,
m_connection_list << connect(m_text_field.data(), &PartDynamicTextField::textWidthChanged,
[this](){this -> updateForm();});
m_change_connections << connect(m_text_field.data(), &PartDynamicTextField::compositeTextChanged,
m_connection_list << connect(m_text_field.data(), &PartDynamicTextField::compositeTextChanged,
[this](){this -> updateForm();});
}
void DynamicTextFieldEditor::disconnectConnections()
{
//Remove previous connection
if(!m_change_connections.isEmpty())
for(const QMetaObject::Connection& con : m_change_connections) {
if(!m_connection_list.isEmpty())
for(const QMetaObject::Connection& con : m_connection_list) {
disconnect(con);
}
m_change_connections.clear();
m_connection_list.clear();
}
/**

3
sources/editor/ui/dynamictextfieldeditor.h
View File

@@ -45,7 +45,7 @@ class DynamicTextFieldEditor : public ElementItemEditor {
bool setParts(QList <CustomElementPart *>) override;
CustomElementPart *currentPart() const override;
QList<CustomElementPart*> currentParts() const override;
void updateFormPriv() override;
void updateForm() override;
private:
void setupWidget();
@@ -73,6 +73,7 @@ class DynamicTextFieldEditor : public ElementItemEditor {
Ui::DynamicTextFieldEditor *ui;
QPointer<PartDynamicTextField> m_text_field;
QList<PartDynamicTextField*> m_parts;
QList<QMetaObject::Connection> m_connection_list;
#ifdef BUILD_WITHOUT_KF5
#else

4
sources/editor/ui/ellipseeditor.cpp
View File

@@ -110,9 +110,9 @@ QList<CustomElementPart *> EllipseEditor::currentParts() const {
}
/**
* @brief EllipseEditor::updateFormPriv
* @brief EllipseEditor::updateForm
*/
void EllipseEditor::updateFormPriv()
void EllipseEditor::updateForm()
{
if (!m_part) {
return;

3
sources/editor/ui/ellipseeditor.h
View File

@@ -43,7 +43,7 @@ class EllipseEditor : public ElementItemEditor
bool setParts(QList<CustomElementPart *> parts) override;
CustomElementPart *currentPart() const override;
QList<CustomElementPart*> currentParts() const override;
void updateFormPriv() override;
void updateForm() override;
private slots:
void on_m_x_sb_editingFinished();
@@ -60,6 +60,7 @@ class EllipseEditor : public ElementItemEditor
Ui::EllipseEditor *ui;
PartEllipse *m_part = nullptr;
StyleEditor *m_style = nullptr;
QList <QMetaObject::Connection> m_change_connections;
};

4
sources/editor/ui/lineeditor.cpp
View File

@@ -176,10 +176,10 @@ QList<CustomElementPart *> LineEditor::currentParts() const {
}
/**
@brief LineEditor::updateFormPriv
@brief LineEditor::updateForm
Reimplemented from ElementItemEditor
*/
void LineEditor::updateFormPriv()
void LineEditor::updateForm()
{
if (!m_part) {
return;

3
sources/editor/ui/lineeditor.h
View File

@@ -43,7 +43,7 @@ class LineEditor : public ElementItemEditor
bool setParts(QList <CustomElementPart *> parts) override;
CustomElementPart *currentPart() const override;
QList<CustomElementPart *> currentParts() const override;
void updateFormPriv() override;
void updateForm() override;
private:
void setUpChangeConnections();
@@ -60,6 +60,7 @@ class LineEditor : public ElementItemEditor
PartLine *m_part = nullptr;
Ui::LineEditor *ui;
StyleEditor *m_style = nullptr;
QList <QMetaObject::Connection> m_change_connections;
bool m_locked = false;
};

4
sources/editor/ui/polygoneditor.cpp
View File

@@ -130,10 +130,10 @@ QList<CustomElementPart*> PolygonEditor::currentParts() const
}
/**
@brief PolygonEditor::updateFormPriv
@brief PolygonEditor::updateForm
Update the widget
*/
void PolygonEditor::updateFormPriv()
void PolygonEditor::updateForm()
{
if (!m_part) {
return;

3
sources/editor/ui/polygoneditor.h
View File

@@ -39,7 +39,7 @@ class PolygonEditor : public ElementItemEditor
bool setPart(CustomElementPart *part) override;
CustomElementPart *currentPart() const override;
QList<CustomElementPart*> currentParts() const override;
void updateFormPriv() override;
void updateForm() override;
QVector<QPointF> pointsFromTree();
bool eventFilter(QObject *watched, QEvent *event) override;
@@ -63,6 +63,7 @@ class PolygonEditor : public ElementItemEditor
Ui::PolygonEditor *ui;
StyleEditor *m_style = nullptr;
PartPolygon *m_part = nullptr;
QList <QMetaObject::Connection> m_change_connections;
};
#endif // POLYGONEDITOR_H

2
sources/editor/ui/rectangleeditor.cpp
View File

@@ -136,7 +136,7 @@ QPointF RectangleEditor::editedTopLeft() const
/**
@brief RectangleEditor::updateForm
*/
void RectangleEditor::updateFormPriv()
void RectangleEditor::updateForm()
{
if (!m_part) {
return;

3
sources/editor/ui/rectangleeditor.h
View File

@@ -48,7 +48,7 @@ class RectangleEditor : public ElementItemEditor
QPointF editedTopLeft () const;
public slots:
void updateFormPriv() override;
void updateForm() override;
private:
void editingFinished();
void activeConnections(bool active);
@@ -70,6 +70,7 @@ class RectangleEditor : public ElementItemEditor
StyleEditor *m_style;
PartRectangle *m_part;
Ui::RectangleEditor *ui;
QList <QMetaObject::Connection> m_change_connections;
};
#endif // RECTANGLEEDITOR_H

4
sources/editor/ui/terminaleditor.cpp
View File

@@ -46,11 +46,11 @@ TerminalEditor::~TerminalEditor()
}
/**
* @brief TerminalEditor::updateFormPriv
* @brief TerminalEditor::updateForm
* Reimplemented from ElementItemEditor
* Update the content of this widget
*/
void TerminalEditor::updateFormPriv()
void TerminalEditor::updateForm()
{
if (!m_part) {
return;

5
sources/editor/ui/terminaleditor.h
View File

@@ -39,7 +39,7 @@ class TerminalEditor : public ElementItemEditor
TerminalEditor(QETElementEditor *editor, QWidget *parent = nullptr);
~TerminalEditor() override;
void updateFormPriv() override;
void updateForm() override;
bool setPart(CustomElementPart *new_part) override;
CustomElementPart *currentPart() const override;
QList<CustomElementPart *> currentParts() const override {return QList<CustomElementPart *>();}
@@ -55,7 +55,8 @@ class TerminalEditor : public ElementItemEditor
private:
Ui::TerminalEditor *ui;
QVector<QMetaObject::Connection> m_editor_connections;
QVector<QMetaObject::Connection> m_editor_connections,
m_change_connections;
PartTerminal *m_part = nullptr;
bool m_locked = false;
};

2
sources/editor/ui/texteditor.cpp
View File

@@ -48,7 +48,7 @@ TextEditor::~TextEditor() {}
@brief TextEditor::updateForm
Update the gui
*/
void TextEditor::updateFormPriv()
void TextEditor::updateForm()
{
if (m_text.isNull()) {
return;

2
sources/editor/ui/texteditor.h
View File

@@ -38,7 +38,7 @@ class TextEditor : public ElementItemEditor {
explicit TextEditor(QETElementEditor *editor, PartText *text = nullptr, QWidget *parent = nullptr);
~TextEditor() override;
void updateFormPriv() override;
void updateForm() override;
bool setPart(CustomElementPart *part) override;
bool setParts(QList <CustomElementPart *>) override;
CustomElementPart *currentPart() const override;

3
sources/elementtextpattern.cpp
View File

@@ -109,7 +109,8 @@ QDomDocument ExportElementTextPattern::xmlConf() const
root.setAttribute("name", m_name);
doc.appendChild(root);
QDomElement elmt = m_element->toXml(doc);
QHash<Terminal *, int> H;
QDomElement elmt = m_element->toXml(doc, H);
QDomElement texts = elmt.firstChildElement("dynamic_texts");
QDomElement groups = elmt.firstChildElement("texts_groups");

8
sources/machine_info.cpp
View File

@@ -150,14 +150,6 @@ void Machine_info::send_info_to_debug()
}
}
/**
@brief Machine_info::~Machine_info
destructor
*/
Machine_info::~Machine_info()
{
}
/**
@brief Machine_info::init_get_Screen_info
Finds the largest screen and saves the values

1
sources/machine_info.h
View File

@@ -34,7 +34,6 @@ public:
int32_t i_max_screen_height();
QString compilation_info();
void send_info_to_debug();
~Machine_info();
signals:

11
sources/properties/elementdata.cpp
View File

@@ -19,18 +19,19 @@
#include "../qetxml.h"
#include <QDebug>
void ElementData::toSettings(QSettings &settings, const QString& prefix) const {
void ElementData::toSettings(QSettings &settings, const QString prefix) const {
Q_UNUSED(settings)
Q_UNUSED(prefix)
}
void ElementData::fromSettings(QSettings &settings, const QString& prefix) {
void ElementData::fromSettings(const QSettings &settings, const QString prefix) {
Q_UNUSED(settings)
Q_UNUSED(prefix)
}
void ElementData::toXmlPriv(QDomElement& e) const {
Q_UNUSED(e)
QDomElement ElementData::toXml(QDomDocument &xml_element) const {
Q_UNUSED(xml_element)
return QDomElement();
}
/**
@@ -41,7 +42,7 @@ void ElementData::toXmlPriv(QDomElement& e) const {
* @param xml_element : tagName must be 'definition'
* @return true is successfuly loaded
*/
bool ElementData::fromXmlPriv(const QDomElement &xml_element)
bool ElementData::fromXml(const QDomElement &xml_element)
{
if(xml_element.tagName() != "definition" ||
xml_element.attribute("type") != "element") {

10
sources/properties/elementdata.h
View File

@@ -18,7 +18,7 @@
#ifndef ELEMENTDATA_H
#define ELEMENTDATA_H
#include "../properties/propertiesinterface.h"
#include "propertiesinterface.h"
#include "../diagramcontext.h"
#include "../NameList/nameslist.h"
@@ -85,10 +85,10 @@ class ElementData : public PropertiesInterface
ElementData() {}
~ElementData() override {}
void toSettings(QSettings &settings, const QString& prefix = QString()) const override;
void fromSettings(QSettings &settings, const QString& prefix = QString()) override;
void toXmlPriv(QDomElement &) const override;
bool fromXmlPriv(const QDomElement &xml_element) override;
void toSettings(QSettings &settings, const QString prefix = QString()) const override;
void fromSettings(const QSettings &settings, const QString prefix = QString()) override;
QDomElement toXml(QDomDocument &xml_element) const override;
bool fromXml(const QDomElement &xml_element) override;
QDomElement kindInfoToXml(QDomDocument &document);
bool operator==(const ElementData &data) const;

215
sources/properties/propertiesinterface.cpp
View File

@@ -16,230 +16,17 @@
along with QElectroTech. If not, see <http://www.gnu.org/licenses/>.
*/
#include "propertiesinterface.h"
#include <QDebug>
#include "../qetxml.h"
/*!
* Available property types
*/
namespace {
const QString userPropertiesS = "userProperties";
}
/**
@brief PropertiesInterface::PropertiesInterface
*/
PropertiesInterface::PropertiesInterface(const QString &tagname):
mTagName(tagname)
PropertiesInterface::PropertiesInterface()
{
}
/**
@brief PropertiesInterface::~PropertiesInterface
*/
PropertiesInterface::~PropertiesInterface()
{
}
void PropertiesInterface::setTagName(const QString& tagname)
{
mTagName = tagname;
}
QString PropertiesInterface::tagName() const
{
return mTagName;
}
QDomElement PropertiesInterface::toXml (QDomDocument &xml_document) const
{
QDomElement element = xml_document.createElement(mTagName);
toXmlPriv(element);
propertiesToXml(element);
return element;
}
bool PropertiesInterface::fromXml (const QDomElement &xml_element)
{
if (!fromXmlPriv(xml_element))
return false;
if (!propertiesFromXml(xml_element))
return false;
return true;
}
bool PropertiesInterface::valideXml(QDomElement& element) {
qDebug(QString("ValideXml() is not implemented. File: %1, Line: %2").arg(__FILE__).arg(__LINE__).toStdString().data());
return false;
}
/**
Permet de convertir une chaine de caracteres ("n", "s", "e" ou "w")
en orientation. Si la chaine fait plusieurs caracteres, seul le
premier est pris en compte. En cas d'incoherence, Qet::North est
retourne.
@param s Chaine de caractere cense representer une orientation
@return l'orientation designee par la chaine de caractere
*/
Qet::Orientation PropertiesInterface::orientationFromString(const QString &s) {
QChar c = s[0];
// in some cases/ old projects? (affuteuse_250h.qet) numbers instead of characters are
// used for the orientation
if (c == 'e' || c == '1') return(Qet::East);
else if (c == 's' || c == '2') return(Qet::South);
else if (c == 'w' || c == '3') return (Qet::West);
else return(Qet::North); // c == '0'
}
/**
@param o une orientation
@return une chaine de caractere representant l'orientation
*/
QString PropertiesInterface::orientationToString(Qet::Orientation o) {
QString ret;
switch(o) {
case Qet::North: ret = "n"; break;
case Qet::East : ret = "e"; break;
case Qet::South: ret = "s"; break;
case Qet::West : ret = "w"; break;
}
return(ret);
}
void PropertiesInterface::deleteUserProperties()
{
properties.clear();
}
int PropertiesInterface::userPropertiesCount() const
{
return properties.count();
}
void PropertiesInterface::setUserProperty(const QString& key, const QVariant& value)
{
properties[key] = value;
}
bool PropertiesInterface::existUserProperty(const QString& key) const
{
return properties.contains(key);
}
QVariant PropertiesInterface::userPropertyValue(const QString& key)
{
if (!existUserProperty(key))
return QVariant();
return properties[key];
}
void PropertiesInterface::propertiesToXml(QDomElement& e) const
{
if (properties.count() == 0)
return;
QDomDocument doc = e.ownerDocument();
auto up = doc.createElement(userPropertiesS);
for (auto i = properties.begin(); i != properties.end(); ++i)
{
auto type = i.value().type();
switch(type) {
case QVariant::Type::String:
up.appendChild(QETXML::createXmlProperty(i.key(), i.value().toString())); break;
case QVariant::Type::Int:
up.appendChild(QETXML::createXmlProperty(i.key(), i.value().toInt())); break;
case QVariant::Type::Double:
up.appendChild(QETXML::createXmlProperty(i.key(), i.value().toDouble())); break;
case QVariant::Type::Bool:
up.appendChild(QETXML::createXmlProperty(i.key(), i.value().toBool())); break;
case QVariant::Type::Color:
up.appendChild(QETXML::createXmlProperty(i.key(), QColor(i.value().value<QColor>()))); break;
default:
break;
}
}
e.appendChild(up);
}
/*!
* \brief PropertiesInterface::propertiesFromXml
* Read all user properties from the DomElement& e
* \param e
* \return
*/
bool PropertiesInterface::propertiesFromXml(const QDomElement& e)
{
QDomNodeList l = e.childNodes();
for (int i=0; i < l.count(); i++)
{
QDomElement userProperties = l.at(i).toElement();
if (userProperties.tagName() != userPropertiesS)
continue;
QDomElement userProperty;
for (int up_index = 0; up_index < userProperties.childNodes().length(); up_index++)
{
userProperty = userProperties.childNodes().at(up_index).toElement();
QString name = userProperty.attribute("name");
QString type = userProperty.attribute("type");
QString value = userProperty.attribute("value");
if (type == QETXML::integerS)
{
int i;
if (QETXML::propertyInteger(value, &i) == QETXML::PropertyFlags::Success)
properties[name] = QVariant(i);
else
return false;
}
else if (type == QETXML::doubleS)
{
double d;
if (QETXML::propertyDouble(value, &d) == QETXML::PropertyFlags::Success)
properties[name] = QVariant(d);
else
return false;
}
else if (type == QETXML::boolS)
{
bool b;
if (QETXML::propertyBool(value, &b) == QETXML::PropertyFlags::Success)
properties[name] = QVariant(b);
else
return false;
}
else if (type == QETXML::uuidS)
{
QUuid u;
if (QETXML::propertyUuid(value, &u) == QETXML::PropertyFlags::Success)
properties[name] = QVariant(u);
else
return false;
}
else if (type == QETXML::colorS)
{
QColor c;
if (QETXML::propertyColor(value, &c) == QETXML::PropertyFlags::Success)
properties[name] = QVariant(c);
else
return false;
}
else if (type == QETXML::stringS)
{
properties[name] = QVariant(value);
}
else
{
qDebug() << "Not a valid property type!";
}
}
}
return true;
}

94
sources/properties/propertiesinterface.h
View File

@@ -20,11 +20,7 @@
#include <QString>
#include <QSettings>
#include <QColor>
#include <QDomElement>
#include <limits>
#include "sources/qet.h"
#include <QUuid>
/**
@brief The PropertiesInterface class
@@ -34,7 +30,7 @@
class PropertiesInterface
{
public:
PropertiesInterface(const QString& tagname = "Properties");
PropertiesInterface();
virtual ~PropertiesInterface();
/**
@brief toSettings
@@ -43,8 +39,8 @@ class PropertiesInterface
befor the name of each paramètre
@param QString
*/
virtual void toSettings(QSettings &,
const QString & = QString()) const =0;
virtual void toSettings (QSettings &settings,
const QString = QString()) const =0;
/**
@brief fromSettings
load properties to setting file.
@@ -52,98 +48,22 @@ class PropertiesInterface
befor the name of each paramètre
@param QString
*/
virtual void fromSettings(QSettings &,
const QString & = QString()) = 0;
virtual void fromSettings (const QSettings &settings,
const QString = QString()) =0;
/**
@brief toXml
Save properties to xml element
@param xml_document
@return QDomElement
*/
virtual QDomElement toXml (QDomDocument &xml_document) const;
virtual QDomElement toXml (QDomDocument &xml_document) const =0;
/**
@brief fromXml
load properties to xml element
@param xml_element
@return true / false
*/
virtual bool fromXml (const QDomElement &xml_element);
/*!
* \brief deleteUserProperties
* Delete all userproperties
*/
void deleteUserProperties();
/*!
* \brief userPropertiesCount
* Returns the number of user properties
* \return
*/
int userPropertiesCount() const;
/*!
* \brief setUserProperty
* Adds a new property if \p key does not exist in the \p properties member,
* otherwise overwrite the value
* \param key
* \param value
*/
void setUserProperty(const QString& key, const QVariant& value);
/*!
* \brief existUserProperty
* Checks if a user property with key \p key is available or not
* \param key
* \return
*/
bool existUserProperty(const QString& key) const;
/*!
* \brief userProperty
* Returns the value of a user property with key \p key
* If \p key is not found, an invalid QVariant is returned.
* Use QVariant::type() to get the type of the vale
* \param key
* \return
*/
QVariant userPropertyValue(const QString& key);
static bool valideXml(QDomElement& element);
void setTagName(const QString& tagname);
QString tagName() const;
/**
Permet de convertir une chaine de caracteres ("n", "s", "e" ou "w")
en orientation. Si la chaine fait plusieurs caracteres, seul le
premier est pris en compte. En cas d'incoherence, Qet::North est
retourne.
@param s Chaine de caractere cense representer une orientation
@return l'orientation designee par la chaine de caractere
*/
static Qet::Orientation orientationFromString(const QString &s);
/**
@param o une orientation
@return une chaine de caractere representant l'orientation
*/
static QString orientationToString(Qet::Orientation o);
private:
virtual void toXmlPriv (QDomElement &e) const =0;
virtual bool fromXmlPriv (const QDomElement &e) =0;
/*!
* \brief PropertiesInterface::propertiesToXml
* Write all user properties to the DomElement \p e
* \param e
*/
void propertiesToXml(QDomElement& e) const;
bool propertiesFromXml (const QDomElement &e);
QHash<QString, QVariant> properties;
QString mTagName{""};
virtual bool fromXml (const QDomElement &xml_element) =0;
};
#endif // PROPERTIESINTERFACE_H

79
sources/properties/terminaldata.cpp
View File

@@ -20,16 +20,14 @@
#include <QGraphicsObject>
#include <QDebug>
#include "../qetxml.h"
TerminalData::TerminalData():
PropertiesInterface("terminaldata")
PropertiesInterface()
{
init();
}
TerminalData::TerminalData(QGraphicsObject *parent):
PropertiesInterface("terminaldata"),
PropertiesInterface(),
q(parent)
{
init();
@@ -61,7 +59,7 @@ void TerminalData::setParent(QGraphicsObject* parent)
@param settings UNUSED
@param prefix UNUSED
*/
void TerminalData::toSettings(QSettings &settings, const QString &prefix) const
void TerminalData::toSettings(QSettings &settings, const QString prefix) const
{
Q_UNUSED(settings)
@@ -76,25 +74,28 @@ void TerminalData::toSettings(QSettings &settings, const QString &prefix) const
@param settings UNUSED
@param prefix UNUSED
*/
void TerminalData::fromSettings(QSettings &settings, const QString& prefix)
void TerminalData::fromSettings(const QSettings &settings, const QString prefix)
{
Q_UNUSED(settings)
Q_UNUSED(prefix)
}
/**
@brief TerminalData::toXmlPriv
@brief TerminalData::toXml
Save properties to xml element
write the name, number, position and orientation of the terminal
to xml_element
@note This method is only called from the PartTerminal
and should never called from the Terminal class
@param e: element to store the properties
@param xml_document
@return xml_element : DomElement with
the name, number, position and orientation of the terminal
*/
void TerminalData::toXmlPriv(QDomElement& xml_element) const
QDomElement TerminalData::toXml(QDomDocument &xml_document) const
{
QDomElement xml_element = xml_document.createElement("terminal");
xml_element.setAttribute("x", QString("%1").arg(q->scenePos().x()));
xml_element.setAttribute("y", QString("%1").arg(q->scenePos().y()));
@@ -102,13 +103,15 @@ void TerminalData::toXmlPriv(QDomElement& xml_element) const
xml_element.setAttribute("name", m_name);
xml_element.setAttribute("orientation",
orientationToString(m_orientation));
Qet::orientationToString(m_orientation));
xml_element.setAttribute("type", typeToString(m_type));
return(xml_element);
}
/*
@brief TerminalData::fromXmlPriv
/**
@brief TerminalData::fromXml
load properties to xml element
@note This method is only called from the PartTerminal
@@ -116,70 +119,44 @@ void TerminalData::toXmlPriv(QDomElement& xml_element) const
@param xml_element
@return true if succeeded / false if the attribute is not real
*/
bool TerminalData::fromXmlPriv(const QDomElement &xml_element)
bool TerminalData::fromXml (const QDomElement &xml_element)
{
qreal term_x = 0.0;
qreal term_y = 0.0;
// reads the position of the terminal
// lit la position de la borne
if (QETXML::propertyDouble(xml_element, "x", &term_x))
if (!QET::attributeIsAReal(xml_element, "x", &term_x))
return false;
if (QETXML::propertyDouble(xml_element, "y", &term_y))
if (!QET::attributeIsAReal(xml_element, "y", &term_y))
return false;
m_pos = QPointF(term_x, term_y);
//emit posFromXML(QPointF(term_x, term_y));
// do not write uuid from this class, because only PartTerminal::fromXml need
// to write it to xml file. Terminal::fromXml does not need.
QString uuid = xml_element.attribute("uuid");
// update part and add uuid, which is used in the new version
// to connect terminals together
// if the attribute not exists, means, the element is created with an
// older version of qet. So use the legacy approach
// to identify terminals
if (!uuid.isEmpty())
m_uuid = QUuid(uuid);
//if (QETXML::propertyString(xml_element, "name", &m_name))
// return false;
QETXML::propertyString(xml_element, "name", &m_name); // some parts do not have a name. Example: affuteuse_250h.qet, Terminal at x="0" y="-20"
QString o;
if (QETXML::propertyString(xml_element, "orientation", &o))
return false;
m_name = xml_element.attribute("name");
// read the orientation of the terminal
// lit l'orientation de la borne
m_orientation = orientationFromString(o);
m_orientation = Qet::orientationFromString(
xml_element.attribute("orientation"));
QString type;
if (QETXML::propertyString(xml_element, "type", &type) == QETXML::PropertyFlags::Success)
m_type = typeFromString(type);
m_type = typeFromString(xml_element.attribute("type"));
return true;
}
bool TerminalData::valideXml(const QDomElement& xml_element) {
if (QETXML::propertyDouble(xml_element, "x"))
return false;
// Old projects do not have this property.
// if (QETXML::propertyString(xml_element, "type"))
// return false;
// legacy elements do not have an uuid
// if (QETXML::propertyUuid(xml_element, "uuid"))
// return false;
//if (QETXML::propertyString(xml_element, "name")) // some parts do not have a name. Example: affuteuse_250h.qet, Terminal at x="0" y="-20"
// return false;
if (QETXML::propertyString(xml_element, "orientation"))
return false;
return true;
}
/**
* @brief TerminalData::typeToString
* @param type

26
sources/properties/terminaldata.h
View File

@@ -19,7 +19,7 @@
#define TERMINALDATA_H
#include "../qet.h"
#include "../properties/propertiesinterface.h"
#include "propertiesinterface.h"
#include <QPointF>
#include <QUuid>
@@ -53,13 +53,11 @@ class TerminalData : public PropertiesInterface
void setParent(QGraphicsObject* parent);
void toSettings(QSettings &settings,
const QString& prefix = QString()) const override;
void fromSettings(QSettings &settings,
const QString& = QString()) override;
void toXmlPriv(QDomElement &xml_element) const override;
bool fromXmlPriv(const QDomElement &xml_element) override;
static bool valideXml(const QDomElement &xml_element);
const QString prefix = QString()) const override;
void fromSettings(const QSettings &settings,
const QString prefix = QString()) override;
QDomElement toXml(QDomDocument &xml_element) const override;
bool fromXml(const QDomElement &xml_element) override;
static QString typeToString(TerminalData::Type type);
static TerminalData::Type typeFromString(const QString &string);
@@ -71,13 +69,13 @@ class TerminalData : public PropertiesInterface
@brief m_orientation
Orientation of the terminal
*/
Qet::Orientation m_orientation{Qet::Orientation::North};
Qet::Orientation m_orientation;
/**
@brief m_second_point
@brief second_point
Position of the second point of the terminal
in scene coordinates
*/
QPointF m_second_point{0,0};
QPointF m_second_point;
/**
@brief m_uuid
Uuid of the terminal.
@@ -92,7 +90,7 @@ class TerminalData : public PropertiesInterface
valid. So if in the loaded document a uuid exists,
use this one and don't create a new one.
*/
QUuid m_uuid; // default is an invalid uuid.
QUuid m_uuid;
/**
@brief m_name
Name of the element.
@@ -110,8 +108,10 @@ class TerminalData : public PropertiesInterface
It is used to store the initial position so that
PartTerminal and Terminal have access to it.
*/
QPointF m_pos{0,0};
QPointF m_pos;
TerminalData::Type m_type = TerminalData::Generic;
private:
QGraphicsObject* q{nullptr};
};

67
sources/properties/xrefproperties.cpp
View File

@@ -22,15 +22,20 @@
#include <QHash>
#include <QMetaEnum>
#include "../qetxml.h"
/**
@brief XRefProperties::XRefProperties
Default Constructor
*/
XRefProperties::XRefProperties()
{
setTagName("xref");
m_show_power_ctc = true;
m_display = Cross;
m_snap_to = Bottom;
m_prefix_keys << "power" << "delay" << "switch";
m_master_label = "%f-%l%c";
m_slave_label = "(%f-%l%c)";
m_offset = 0;
m_xref_pos = Qt::AlignBottom;
}
/**
@@ -40,7 +45,7 @@ XRefProperties::XRefProperties()
@param prefix: prefix before properties name
*/
void XRefProperties::toSettings(QSettings &settings,
const QString &prefix) const
const QString prefix) const
{
settings.setValue(prefix + "showpowerctc", m_show_power_ctc);
QString display = m_display == Cross? "cross" : "contacts";
@@ -69,8 +74,8 @@ void XRefProperties::toSettings(QSettings &settings,
@param settings: QSettings to use
@param prefix: prefix before properties name
*/
void XRefProperties::fromSettings(QSettings &settings,
const QString &prefix)
void XRefProperties::fromSettings(const QSettings &settings,
const QString prefix)
{
m_show_power_ctc = settings.value(prefix + "showpowerctc", true).toBool();
QString display = settings.value(prefix + "displayhas", "cross").toString();
@@ -95,8 +100,10 @@ void XRefProperties::fromSettings(QSettings &settings,
@param xml_document : QDomElement to use for saving
@return QDomElement
*/
void XRefProperties::toXmlPriv(QDomElement& xml_element) const
QDomElement XRefProperties::toXml(QDomDocument &xml_document) const
{
QDomElement xml_element = xml_document.createElement("xref");
xml_element.setAttribute("type", m_key);
xml_element.setAttribute("showpowerctc", m_show_power_ctc? "true" : "false");
@@ -119,42 +126,36 @@ void XRefProperties::toXmlPriv(QDomElement& xml_element) const
foreach (QString key, m_prefix.keys()) {
xml_element.setAttribute(key + "prefix", m_prefix.value(key));
}
return xml_element;
}
/** RETURNS True
@brief XRefProperties::fromXmlPriv
/**
@brief XRefProperties::fromXml
Load from xml
@param xml_element: QDomElement to use for load
*/
bool XRefProperties::fromXmlPriv(const QDomElement &xml_element) {
if (QETXML::propertyBool(xml_element, "showpowerctc", &m_show_power_ctc))
return false;
QString display;
if (QETXML::propertyString(xml_element, "displayhas", &display) != QETXML::PropertyFlags::NotFound) {
bool XRefProperties::fromXml(const QDomElement &xml_element) {
m_show_power_ctc = xml_element.attribute("showpowerctc") == "true";
QString display = xml_element.attribute("displayhas", "cross");
display == "cross"? m_display = Cross : m_display = Contacts;
}
QString snap;
if (QETXML::propertyString(xml_element, "snapto", &snap) != QETXML::PropertyFlags::NotFound) {
QString snap = xml_element.attribute("snapto", "label");
snap == "bottom"? m_snap_to = Bottom : m_snap_to = Label;
}
QString xrefpos;
if (QETXML::propertyString(xml_element, "xrefpos", &xrefpos) != QETXML::PropertyFlags::NotFound) {
QString xrefpos = xml_element.attribute("xrefpos","Left");
QMetaEnum var = QMetaEnum::fromType<Qt::Alignment>();
m_xref_pos = Qt::AlignmentFlag(var.keyToValue(xrefpos.toStdString().data()));
}
// TODO: why it compiles without this true??
QETXML::propertyInteger(xml_element, "offset", &m_offset);
QETXML::propertyString(xml_element, "master_label", &m_master_label);
QETXML::propertyString(xml_element, "slave_label", &m_slave_label);
QString value;
if(xml_element.hasAttribute("xrefpos"))
m_xref_pos = Qt::AlignmentFlag(var.keyToValue(xml_element.attribute("xrefpos").toStdString().data()));
else
m_xref_pos = Qt::AlignBottom;
m_offset = xml_element.attribute("offset", "0").toInt();
m_master_label = xml_element.attribute("master_label", "%f-%l%c");
m_slave_label = xml_element.attribute("slave_label","(%f-%l%c)");
foreach (QString key, m_prefix_keys) {
if (!QETXML::propertyString(xml_element, key + "prefix", &value))
m_prefix.insert(key, value);
m_prefix.insert(key, xml_element.attribute(key + "prefix"));
}
return true;
}

27
sources/properties/xrefproperties.h
View File

@@ -42,11 +42,12 @@ class XRefProperties : public PropertiesInterface
Label
};
void toSettings (QSettings &settings, const QString& = QString()) const override;
void fromSettings (QSettings &settings,
const QString& = QString()) override;
void toXmlPriv(QDomElement&xml_element) const override;
bool fromXmlPriv(const QDomElement &xml_element) override;
void toSettings (QSettings &settings,
const QString = QString()) const override;
void fromSettings (const QSettings &settings,
const QString = QString()) override;
QDomElement toXml (QDomDocument &xml_document) const override;
bool fromXml(const QDomElement &xml_element) override;
static QHash<QString, XRefProperties> defaultProperties();
@@ -79,15 +80,15 @@ class XRefProperties : public PropertiesInterface
void setKey(QString& key) {m_key = key;}
private:
bool m_show_power_ctc{true};
DisplayHas m_display{Cross};
SnapTo m_snap_to{Bottom};
Qt::AlignmentFlag m_xref_pos{Qt::AlignBottom};
bool m_show_power_ctc;
DisplayHas m_display;
SnapTo m_snap_to;
Qt::AlignmentFlag m_xref_pos;
QHash <QString, QString> m_prefix;
QStringList m_prefix_keys{"power","delay","switch"};
QString m_master_label{"%f-%l%c"};
QString m_slave_label{"(%f-%l%c)"};
int m_offset{0};
QStringList m_prefix_keys;
QString m_master_label;
QString m_slave_label;
int m_offset;
QString m_key;
};

25
sources/qet.cpp
View File

@@ -34,6 +34,31 @@
retourne.
@param s Chaine de caractere cense representer une orientation
@return l'orientation designee par la chaine de caractere
*/
Qet::Orientation Qet::orientationFromString(const QString &s) {
QChar c = s[0];
if (c == 'e') return(Qet::East);
else if (c == 's') return(Qet::South);
else if (c == 'w') return (Qet::West);
else return(Qet::North);
}
/**
@param o une orientation
@return une chaine de caractere representant l'orientation
*/
QString Qet::orientationToString(Qet::Orientation o) {
QString ret;
switch(o) {
case Qet::North: ret = "n"; break;
case Qet::East : ret = "e"; break;
case Qet::South: ret = "s"; break;
case Qet::West : ret = "w"; break;
}
return(ret);
}
/**
Indique si deux orientations de Borne sont sur le meme axe (Vertical / Horizontal).
@param a La premiere orientation de Borne
@param b La seconde orientation de Borne

183
sources/qetgraphicsitem/conductor.cpp
View File

@@ -31,8 +31,6 @@
#include "element.h"
#include "../QetGraphicsItemModeler/qetgraphicshandleritem.h"
#include "../qetxml.h"
#include <QMultiHash>
#include <QtDebug>
@@ -80,9 +78,15 @@ class ConductorXmlRetroCompatibility
*/
Conductor::Conductor(Terminal *p1, Terminal* p2) :
terminal1(p1),
terminal2(p2)
terminal2(p2),
m_mouse_over(false),
m_text_item(nullptr),
segments(nullptr),
m_moving_segment(false),
modified_path(false),
has_to_save_profile(false),
must_highlight_(Conductor::None)
{
setTagName("conductor");
//set Zvalue at 11 to be upper than the DiagramImageItem and element
setZValue(11);
m_previous_z_value = zValue();
@@ -583,16 +587,36 @@ ConductorTextItem *Conductor::textItem() const
@return true si l'element XML represente bien un Conducteur ; false sinon
*/
bool Conductor::valideXml(QDomElement &e){
// verifie le nom du tag
if (e.tagName() != "conductor") return(false);
// // TODO: seems to short! (see fromXML)
// if (QETXML::propertyDouble(e, "x") ||
// QETXML::propertyDouble(e, "y"))
// return false;
// verifie la presence des attributs minimaux
if (!e.hasAttribute("terminal1")) return(false);
if (!e.hasAttribute("terminal2")) return(false);
// if (QETXML::propertyBool(e, "freezeLabel"))
// return false;
bool conv_ok;
// parse l'abscisse
if (e.hasAttribute("element1")) {
if (QUuid(e.attribute("element1")).isNull())
return false;
if (QUuid(e.attribute("terminal1")).isNull())
return false;
} else {
e.attribute("terminal1").toInt(&conv_ok);
if (!conv_ok) return(false);
}
return true;
// parse l'ordonnee
if (e.hasAttribute("element2")) {
if (QUuid(e.attribute("element2")).isNull())
return false;
if (QUuid(e.attribute("terminal2")).isNull())
return false;
} else {
e.attribute("terminal2").toInt(&conv_ok);
if (!conv_ok) return(false);
}
return(true);
}
/**
@@ -965,26 +989,16 @@ void Conductor::pointsToSegments(const QList<QPointF>& points_list) {
@param dom_element
@return true is loading success else return false
*/
bool Conductor::fromXmlPriv(const QDomElement &dom_element)
bool Conductor::fromXml(QDomElement &dom_element)
{
double x=0, y=0;
QETXML::propertyDouble(dom_element, "x", &x);
QETXML::propertyDouble(dom_element, "y", &y);
setPos(x, y);
setPos(dom_element.attribute("x", nullptr).toDouble(),
dom_element.attribute("y", nullptr).toDouble());
bool return_ = pathFromXml(dom_element);
m_text_item -> fromXml(dom_element);
auto prs = QETXML::findInDomElement(dom_element, ConductorProperties::xmlTagName());
ConductorProperties pr;
if (!prs.isEmpty()) {
pr.fromXml(prs.first());
} else {
// legacy
// added in 0.9 remove in later version!
pr.fromXml(dom_element);
}
//Load Sequential Values
if (dom_element.hasAttribute("sequ_1") || dom_element.hasAttribute("sequf_1") || dom_element.hasAttribute("seqt_1") || dom_element.hasAttribute("seqtf_1") || dom_element.hasAttribute("seqh_1") || dom_element.hasAttribute("sequf_1"))
@@ -992,15 +1006,15 @@ bool Conductor::fromXmlPriv(const QDomElement &dom_element)
else
m_autoNum_seq.fromXml(dom_element.firstChildElement("sequentialNumbers"));
QETXML::propertyBool(dom_element, "freezeLabel", &m_freeze_label);
m_freeze_label = dom_element.attribute("freezeLabel") == "true"? true : false;
setProperties(pr);
return return_;
}
// does not support legacy method
/*!
@brief Conductor::toXmlPriv
/**
@brief Conductor::toXml
Exporte les caracteristiques du conducteur sous forme d'une element XML.
@param dom_document :
Le document XML a utiliser pour creer l'element XML
@@ -1009,7 +1023,11 @@ bool Conductor::fromXmlPriv(const QDomElement &dom_element)
bornes dans le document XML et leur adresse en memoire
@return Un element XML representant le conducteur
*/
void Conductor::toXmlPriv(QDomElement& dom_element) const {
QDomElement Conductor::toXml(QDomDocument &dom_document,
QHash<Terminal *,
int> &table_adr_id) const
{
QDomElement dom_element = dom_document.createElement("conductor");
dom_element.setAttribute("x", QString::number(pos().x()));
dom_element.setAttribute("y", QString::number(pos().y()));
@@ -1017,7 +1035,7 @@ void Conductor::toXmlPriv(QDomElement& dom_element) const {
// Terminal is uniquely identified by the uuid of the terminal and the element
if (terminal1->uuid().isNull()) {
// legacy method to identify the terminal
dom_element.setAttribute("terminal1", terminal1->ID()); // for backward compability
dom_element.setAttribute("terminal1", table_adr_id.value(terminal1)); // for backward compability
} else {
dom_element.setAttribute("element1", terminal1->parentElement()->uuid().toString());
dom_element.setAttribute("terminal1", terminal1->uuid().toString());
@@ -1025,7 +1043,7 @@ void Conductor::toXmlPriv(QDomElement& dom_element) const {
if (terminal2->uuid().isNull()) {
// legacy method to identify the terminal
dom_element.setAttribute("terminal2", terminal2->ID()); // for backward compability
dom_element.setAttribute("terminal2", table_adr_id.value(terminal2)); // for backward compability
} else {
dom_element.setAttribute("element2", terminal2->parentElement()->uuid().toString());
dom_element.setAttribute("terminal2", terminal2->uuid().toString());
@@ -1040,18 +1058,18 @@ void Conductor::toXmlPriv(QDomElement& dom_element) const {
QDomElement current_segment;
foreach(ConductorSegment *segment, segmentsList())
{
current_segment = dom_element.ownerDocument().createElement("segment");
current_segment = dom_document.createElement("segment");
current_segment.setAttribute("orientation", segment -> isHorizontal() ? "horizontal" : "vertical");
current_segment.setAttribute("length", QString("%1").arg(segment -> length()));
dom_element.appendChild(current_segment);
}
}
QDomDocument doc = dom_element.ownerDocument();
QDomElement dom_seq = m_autoNum_seq.toXml(doc);
QDomElement dom_seq = m_autoNum_seq.toXml(dom_document);
dom_element.appendChild(dom_seq);
// Export the properties and text
dom_element.appendChild(m_properties. toXml(doc));
m_properties. toXml(dom_element);
if(m_text_item->wasMovedByUser())
{
dom_element.setAttribute("userx", QString::number(m_text_item->pos().x()));
@@ -1059,72 +1077,16 @@ void Conductor::toXmlPriv(QDomElement& dom_element) const {
}
if(m_text_item->wasRotateByUser())
dom_element.setAttribute("rotation", QString::number(m_text_item->rotation()));
return(dom_element);
}
/**
Exporte les caracteristiques du conducteur sous forme d'une element XML.
@param d Le document XML a utiliser pour creer l'element XML
@param table_adr_id Hash stockant les correspondances entre les ids des
bornes dans le document XML et leur adresse en memoire
@return Un element XML representant le conducteur
*/
//QDomElement Conductor::toXml(QDomDocument &dom_document, QHash<Terminal *, int> &table_adr_id) const
//{
// QDomElement dom_element = dom_document.createElement("conductor");
// dom_element.setAttribute("x", QString::number(pos().x()));
// dom_element.setAttribute("y", QString::number(pos().y()));
// // Terminal is uniquely identified by the uuid of the terminal and the element
// if (terminal1->uuid().isNull()) {
// // legacy method to identify the terminal
// dom_element.setAttribute("terminal1", table_adr_id.value(terminal1)); // for backward compability
// } else {
// dom_element.setAttribute("element1", terminal1->parentElement()->uuid().toString());
// dom_element.setAttribute("terminal1", terminal1->uuid().toString());
// }
// if (terminal2->uuid().isNull()) {
// // legacy method to identify the terminal
// dom_element.setAttribute("terminal2", table_adr_id.value(terminal2)); // for backward compability
// } else {
// dom_element.setAttribute("element2", terminal2->parentElement()->uuid().toString());
// dom_element.setAttribute("terminal2", terminal2->uuid().toString());
// }
// dom_element.setAttribute("freezeLabel", m_freeze_label? "true" : "false");
// // on n'exporte les segments du conducteur que si ceux-ci ont
// // ete modifies par l'utilisateur
// if (modified_path)
// {
// // parcours et export des segments
// QDomElement current_segment;
// foreach(ConductorSegment *segment, segmentsList())
// {
// current_segment = dom_document.createElement("segment");
// current_segment.setAttribute("orientation", segment -> isHorizontal() ? "horizontal" : "vertical");
// current_segment.setAttribute("length", QString("%1").arg(segment -> length()));
// dom_element.appendChild(current_segment);
// }
// }
// QDomElement dom_seq = m_autoNum_seq.toXml(dom_document);
// dom_element.appendChild(dom_seq);
// // Export the properties and text
// m_properties.toXml(dom_document);
// if(m_text_item->wasMovedByUser())
// {
// dom_element.setAttribute("userx", QString::number(m_text_item->pos().x()));
// dom_element.setAttribute("usery", QString::number(m_text_item->pos().y()));
// }
// if(m_text_item->wasRotateByUser())
// dom_element.setAttribute("rotation", QString::number(m_text_item->rotation()));
// return(dom_element);
//}
/**
@brief Conductor::pathFromXml
Generate the path (of the line) from xml file by checking the segments in the xml
file
@param e
@return true if generate path success else return false
*/
bool Conductor::pathFromXml(const QDomElement &e) {
// parcourt les elements XML "segment" et en extrait deux listes de longueurs
@@ -1136,21 +1098,14 @@ bool Conductor::pathFromXml(const QDomElement &e) {
if (current_segment.isNull() || current_segment.tagName() != "segment") continue;
// le segment doit avoir une longueur
qreal segment_length;
if (QETXML::propertyDouble(current_segment, "length", & segment_length))
continue;
if (!current_segment.hasAttribute("length")) continue;
bool isHorizontal = false;
QString orientation;
if (QETXML::propertyString(current_segment, "orientation", &orientation) == QETXML::PropertyFlags::Success) {
if (orientation == "horizontal")
isHorizontal = true;
} else {
qDebug() << "PathFromXML failed";
return false;
}
// cette longueur doit etre un reel
bool ok;
qreal segment_length = current_segment.attribute("length").toDouble(&ok);
if (!ok) continue;
if (isHorizontal) {
if (current_segment.attribute("orientation") == "horizontal") {
segments_x << segment_length;
segments_y << 0.0;
} else {
@@ -1401,7 +1356,7 @@ void Conductor::calculateTextItemPosition()
}
//Adjust the position of text if his rotation
//is 0?? or 270??, to be exactly centered to the conductor
//is 0° or 270°, to be exactly centered to the conductor
if (m_text_item -> rotation() == 0)
{
text_pos.rx() -= m_text_item -> boundingRect().width()/2;
@@ -1678,12 +1633,12 @@ void Conductor::displayedTextChanged()
new_value.setValue(new_properties);
QUndoCommand *undo = new QUndoCommand(tr("Modifier les propri??t??s d'un conducteur", "undo caption"));
QUndoCommand *undo = new QUndoCommand(tr("Modifier les propriétés d'un conducteur", "undo caption"));
new QPropertyUndoCommand(this, "properties", old_value, new_value, undo);
if (!relatedPotentialConductors().isEmpty())
{
undo->setText(tr("Modifier les propri??t??s de plusieurs conducteurs", "undo caption"));
undo->setText(tr("Modifier les propriétés de plusieurs conducteurs", "undo caption"));
foreach (Conductor *potential_conductor, relatedPotentialConductors())
{

27
sources/qetgraphicsitem/conductor.h
View File

@@ -20,8 +20,6 @@
#include "../autoNum/assignvariables.h"
#include "../conductorproperties.h"
#include "../conductorproperties.h"
#include "../properties/propertiesinterface.h"
#include <QGraphicsPathItem>
class ConductorProfile;
@@ -41,7 +39,7 @@ typedef QHash<Qt::Corner, ConductorProfile> ConductorProfilesGroup;
This class represents a conductor, i.e. a wire between two element
terminals.
*/
class Conductor : public QGraphicsObject, public PropertiesInterface
class Conductor : public QGraphicsObject
{
Q_OBJECT
@@ -102,10 +100,11 @@ class Conductor : public QGraphicsObject, public PropertiesInterface
public:
static bool valideXml (QDomElement &);
bool fromXmlPriv(const QDomElement &) override;
void toXmlPriv(QDomElement&dom_element) const override;
void toSettings(QSettings &, const QString & = QString()) const override {}
void fromSettings(QSettings &, const QString & = QString()) override {}
bool fromXml (QDomElement &);
QDomElement toXml (
QDomDocument &,
QHash<Terminal *,
int> &) const;
private:
bool pathFromXml(const QDomElement &);
@@ -182,28 +181,28 @@ class Conductor : public QGraphicsObject, public PropertiesInterface
QVector<QetGraphicsHandlerItem *> m_handler_vector;
int m_vector_index = -1;
bool m_mouse_over{false};
bool m_mouse_over;
/// Functional properties
ConductorProperties m_properties;
/// Text input for non simple, non-singleline conductors
ConductorTextItem *m_text_item{nullptr};
ConductorTextItem *m_text_item;
/// Segments composing the conductor
ConductorSegment *segments{nullptr};
ConductorSegment *segments;
/// Attributs related to mouse interaction
bool m_moving_segment{false};
bool m_moving_segment;
int moved_point;
qreal m_previous_z_value;
ConductorSegment *m_moved_segment;
QPointF before_mov_text_pos_;
/// Whether the conductor was manually modified by users
bool modified_path{false};
bool modified_path;
/// Whether the current profile should be saved as soon as possible
bool has_to_save_profile{false};
bool has_to_save_profile;
/// conductor profile: "photography" of what the conductor is supposed to look
/// like - there is one profile per kind of traject
ConductorProfilesGroup conductor_profiles;
/// Define whether and how the conductor should be highlighted
Highlight must_highlight_{Conductor::None};
Highlight must_highlight_;
bool m_valid;
bool m_freeze_label = false;

20
sources/qetgraphicsitem/conductortextitem.cpp
View File

@@ -21,15 +21,15 @@
#include "../diagramcommands.h"
#include "../qetgraphicsitem/conductor.h"
#include "../qetxml.h"
/**
Constructeur
@param parent_conductor Conducteur auquel ce texte est rattache
*/
ConductorTextItem::ConductorTextItem(Conductor *parent_conductor) :
DiagramTextItem(parent_conductor),
parent_conductor_(parent_conductor)
parent_conductor_(parent_conductor),
moved_by_user_(false),
rotate_by_user_(false)
{
setAcceptHoverEvents(true);
}
@@ -69,17 +69,13 @@ Conductor *ConductorTextItem::parentConductor() const
@param e
*/
void ConductorTextItem::fromXml(const QDomElement &e) {
double userx=0, usery=0;
if (QETXML::propertyDouble(e, "userx", &userx) == QETXML::PropertyFlags::Success &&
QETXML::propertyDouble(e, "usery", &usery) == QETXML::PropertyFlags::Success) {
setPos(userx, usery);
if (e.hasAttribute("userx")) {
setPos(e.attribute("userx").toDouble(),
e.attribute("usery").toDouble());
moved_by_user_ = true;
}
double rotation;
if (QETXML::propertyDouble(e, "rotation", &rotation) == QETXML::PropertyFlags::Success) {
setRotation(rotation);
if (e.hasAttribute("rotation")) {
setRotation(e.attribute("rotation").toDouble());
rotate_by_user_ = true;
}
}

4
sources/qetgraphicsitem/conductortextitem.h
View File

@@ -61,8 +61,8 @@ class ConductorTextItem : public DiagramTextItem
// attributes
private:
Conductor *parent_conductor_;
bool moved_by_user_{false};
bool rotate_by_user_{false};
bool moved_by_user_;
bool rotate_by_user_;
QPointF before_mov_pos_;
};
#endif

2
sources/qetgraphicsitem/dynamicelementtextitem.cpp
View File

@@ -216,7 +216,7 @@ void DynamicElementTextItem::fromXml(const QDomElement &dom_elmt)
setColor(QColor(dom_color.text()));
//Force the update of the displayed text
setTextFrom(m_text_from); // TODO: does not update because there is a retrun inside if the textfrom argument is the same as m_text_from
setTextFrom(m_text_from);
QGraphicsTextItem::setPos(dom_elmt.attribute("x", QString::number(0)).toDouble(),
dom_elmt.attribute("y", QString::number(0)).toDouble());

4
sources/qetgraphicsitem/dynamicelementtextitem.h
View File

@@ -82,7 +82,7 @@ class DynamicElementTextItem : public DiagramTextItem
DynamicElementTextItem(const DynamicElementTextItem &);
public:
QDomElement toXml(QDomDocument&) const override;
QDomElement toXml(QDomDocument &dom_doc) const override;
void fromXml(const QDomElement &dom_elmt) override;
Element *parentElement() const;
@@ -160,7 +160,7 @@ class DynamicElementTextItem : public DiagramTextItem
QList<QMetaObject::Connection>
m_formula_connection,
m_update_slave_Xref_connection;
QColor m_user_color{QColor()};
QColor m_user_color;
bool
m_frame = false,
m_first_scene_change = true;

95
sources/qetgraphicsitem/element.cpp
View File

@@ -98,8 +98,7 @@ Element::Element(
}
}
int elmt_state;
qDebug() << "\tCollection Path: " << location.collectionPath();
buildFromXml(location.xml(), &elmt_state); // build from the collection definition
buildFromXml(location.xml(), &elmt_state);
if (state) {
*state = elmt_state;
}
@@ -402,7 +401,7 @@ void Element::drawHighlight(
/**
@brief Element::buildFromXml
Build this element from an xml description (from the collection)
Build this element from an xml description
@param xml_def_elmt
@param state
Optional pointer which define the status of build
@@ -435,9 +434,9 @@ bool Element::buildFromXml(const QDomElement &xml_def_elmt, int *state)
if (conv_ok && QET::version.toDouble() < element_version)
{
std::cerr << qPrintable(
QObject::tr("Avertissement : l'??l??ment "
" a ??t?? enregistr?? avec une version"
" ult??rieure de QElectroTech.")
QObject::tr("Avertissement : l'élément "
" a été enregistré avec une version"
" ultérieure de QElectroTech.")
) << std::endl;
}
}
@@ -519,15 +518,11 @@ bool Element::buildFromXml(const QDomElement &xml_def_elmt, int *state)
if (qde.isNull())
continue;
qDebug() << "\t\tElement.cpp:buildFromXml;parseElement: " << qde.tagName();
if (parseElement(qde)) { // TODO: why lines are not parsed here?
qDebug() << "\t\t\tParsing Element success";
if (parseElement(qde)) {
++ parsed_elements_count;
}
else
{
qDebug() << "\t\t\tParsing Element no success";
if (state)
*state = 7;
m_state = QET::GIOK;
@@ -553,12 +548,14 @@ bool Element::buildFromXml(const QDomElement &xml_def_elmt, int *state)
m_state = QET::GIOK;
return(false);
}
else
{
if (state)
*state = 0;
m_state = QET::GIOK;
return(true);
}
}
/**
@brief Element::parseElement
@@ -661,11 +658,13 @@ DynamicElementTextItem *Element::parseDynamicText(
*/
Terminal *Element::parseTerminal(const QDomElement &dom_element)
{
if (!Terminal::valideXml(dom_element))
TerminalData* data = new TerminalData();
if (!data->fromXml(dom_element)) {
delete data;
return nullptr;
}
Terminal *new_terminal = new Terminal(0, 0, Qet::Orientation::North, this); // does not matter which values are typed in here, because they get overwritten by the fromXML() function
new_terminal->fromXml(dom_element);
Terminal *new_terminal = new Terminal(data, this);
m_terminals << new_terminal;
//Sort from top to bottom and left to rigth
@@ -680,7 +679,7 @@ Terminal *Element::parseTerminal(const QDomElement &dom_element)
return (a->dockConductor().y() < b->dockConductor().y());
});
return(new_terminal); // TODO: makes no sense
return(new_terminal);
}
/**
@@ -722,14 +721,15 @@ bool Element::valideXml(QDomElement &e) {
*/
bool Element::fromXml(
QDomElement &e,
QHash<int, Terminal *> &table_id_adr)
QHash<int,
Terminal *> &table_id_adr)
{
m_state = QET::GILoadingFromXml;
/*
les bornes vont maintenant etre recensees pour associer leurs id a leur adresse reelle
ce recensement servira lors de la mise en place des fils
*/
QList<QDomElement> liste_terminals; // terminals in the element in the diagram
QList<QDomElement> liste_terminals;
foreach(QDomElement qde,
QET::findInDomElement(e, "terminals", "terminal")) {
if (Terminal::valideXml(qde)) liste_terminals << qde;
@@ -737,29 +737,15 @@ bool Element::fromXml(
QHash<int, Terminal *> priv_id_adr;
int terminals_non_trouvees = 0;
// The added childs from the collection now must match with the terminals from the diagram. Iterate through
// all Terminals in the collection and in the diagram to link them together
for(QGraphicsItem *qgi: childItems()) { // TODO: Where the Terminals are added as childs?
foreach(QGraphicsItem *qgi, childItems()) {
if (Terminal *p = qgraphicsitem_cast<Terminal *>(qgi)) {
bool terminal_trouvee = false;
for(QDomElement qde: liste_terminals) {
// The position in the collection element definition is the origin position (originPos).
// The position in the diagram element definition is the position where the conductor is connected (dock position)
// Therefore a simple operator overloading is not possible.
Terminal diagramTerminal(0,0, Qet::Orientation::East);
diagramTerminal.fromXml(qde);
QPointF dockPos1 = diagramTerminal.originPos(); // position here is directly the dock_elmt_ position (stored in the diagram)
QPointF dockPos2 = p->dockPos();
if (qFuzzyCompare(dockPos1.x(), dockPos2.x()) &&
qFuzzyCompare(dockPos1.y(), dockPos2.y()) &&
p->orientation() == diagramTerminal.orientation()) { // check if the part in the collection is the same as in the diagram stored
qDebug() << "Matching Terminal found.";
// store id for legacy purpose, because when opening a old project in the collection the terminal does not have an uuid. Therefore the id must be used
if (p->uuid().isNull()) {
p->setID(qde.attribute("id").toInt());
}
priv_id_adr.insert(qde.attribute("id").toInt(), p);
foreach(QDomElement qde, liste_terminals) {
if (p -> fromXml(qde)) {
priv_id_adr.insert(
qde.attribute(
"id").toInt(),
p);
terminal_trouvee = true;
// We used to break here, because we did not expect
// several terminals to share the same position.
@@ -772,7 +758,6 @@ bool Element::fromXml(
if (terminals_non_trouvees > 0)
{
qDebug() << "element.cpp: Element::fromXML; Elements not found: " << terminals_non_trouvees;
m_state = QET::GIOK;
return(false);
}
@@ -796,9 +781,9 @@ bool Element::fromXml(
}
//load uuid of connected elements
QList <QDomElement> uuid_list = QET::findInDomElement(e, "links_uuids", "link_uuid");
foreach (QDomElement qdo, uuid_list) tmp_uuids_link << qdo.attribute("uuid");
QList <QDomElement> uuid_list = QET::findInDomElement(e,
"links_uuids",
"link_uuid");
foreach (QDomElement qdo, uuid_list)
#if QT_VERSION < QT_VERSION_CHECK(6, 0, 0) // ### Qt 6: remove
tmp_uuids_link << qdo.attribute("uuid");
@@ -852,7 +837,7 @@ bool Element::fromXml(
//************************//
//***Dynamic texts item***//
//************************// read from the diagram section
//************************//
for (const QDomElement& qde : QET::findInDomElement(
e,
"dynamic_texts",
@@ -907,7 +892,9 @@ bool Element::fromXml(
\~French L'element XML representant cet element electrique
*/
QDomElement Element::toXml(
QDomDocument &document) const
QDomDocument &document,
QHash<Terminal *,
int> &table_adr_id) const
{
QDomElement element = document.createElement("element");
@@ -934,6 +921,18 @@ QDomElement Element::toXml(
element.setAttribute("z", QString::number(this->zValue()));
element.setAttribute("orientation", QString::number(orientation()));
/* get the first id to use for the bounds of this element
* recupere le premier id a utiliser pour les bornes de cet element */
int id_terminal = 0;
if (!table_adr_id.isEmpty()) {
// trouve le plus grand id
int max_id_t = -1;
foreach (int id_t, table_adr_id.values()) {
if (id_t > max_id_t) max_id_t = id_t;
}
id_terminal = max_id_t + 1;
}
// registration of device terminals
// enregistrement des bornes de l'appareil
QDomElement xml_terminals = document.createElement("terminals");
@@ -942,10 +941,8 @@ QDomElement Element::toXml(
foreach(Terminal *t, terminals()) {
// alors on enregistre la borne
QDomElement terminal = t -> toXml(document);
if (t->ID() > 0) {
// for backward compatibility
terminal.setAttribute("id", t->ID()); // for backward compatibility
}
terminal.setAttribute("id", id_terminal); // for backward compatibility
table_adr_id.insert(t, id_terminal ++);
xml_terminals.appendChild(terminal);
}
element.appendChild(xml_terminals);

14
sources/qetgraphicsitem/element.h
View File

@@ -1,4 +1,4 @@
/*
/*
Copyright 2006-2021 The QElectroTech Team
This file is part of QElectroTech.
@@ -39,7 +39,7 @@ class ElementTextItemGroup;
/**
This is the base class for electrical elements.
*/
class Element : public QetGraphicsItem // TODO: derive from propertiesInterface!
class Element : public QetGraphicsItem
{
friend class DiagramEventAddElement;
@@ -140,8 +140,14 @@ class Element : public QetGraphicsItem // TODO: derive from propertiesInterface!
QPoint hotspot() const;
void editProperty() override;
static bool valideXml(QDomElement &);
virtual bool fromXml(QDomElement &, QHash<int, Terminal *> &);
virtual QDomElement toXml(QDomDocument &) const;
virtual bool fromXml(
QDomElement &,
QHash<int,
Terminal *> &);
virtual QDomElement toXml(
QDomDocument &,
QHash<Terminal *,
int> &) const;
QUuid uuid() const;
int orientation() const;

1
sources/qetgraphicsitem/elementtextitemgroup.cpp
View File

@@ -438,7 +438,6 @@ QDomElement ElementTextItemGroup::toXml(QDomDocument &dom_document) const
return dom_element;
}
// TOOD: inherit from propertiesinterface
/**
@brief ElementTextItemGroup::fromXml
Import data of this group from xml

4
sources/qetgraphicsitem/elementtextitemgroup.h
View File

@@ -32,7 +32,7 @@ class CrossRefItem;
This class represent a group of element text
Texts in the group can be aligned left / center /right
*/
class ElementTextItemGroup : public QObject, public QGraphicsItemGroup // TODO: derive from PropertiesInterface
class ElementTextItemGroup : public QObject, public QGraphicsItemGroup
{
Q_OBJECT
@@ -112,7 +112,7 @@ class ElementTextItemGroup : public QObject, public QGraphicsItemGroup // TODO:
m_hold_to_bottom_of_page = false,
m_block_alignment_update = false,
m_frame = false;
QPointF m_initial_position{QPointF(0,0)};
QPointF m_initial_position;
int m_vertical_adjustment = 0;
CrossRefItem *m_Xref_item = nullptr;
Element *m_parent_element = nullptr;

1
sources/qetgraphicsitem/independenttextitem.cpp
View File

@@ -51,7 +51,6 @@ IndependentTextItem::~IndependentTextItem()
{
}
// TODO: inherit from PropertiesInterface
/**
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

5
sources/qetgraphicsitem/qetgraphicsitem.cpp
View File

@@ -25,7 +25,10 @@
@param parent : Parent Item
*/
QetGraphicsItem::QetGraphicsItem(QGraphicsItem *parent):
QGraphicsObject(parent)
QGraphicsObject(parent),
is_movable_(true),
m_first_move(true),
snap_to_grid_(true)
{}
QetGraphicsItem::~QetGraphicsItem()

8
sources/qetgraphicsitem/qetgraphicsitem.h
View File

@@ -56,10 +56,10 @@ class QetGraphicsItem : public QGraphicsObject
void mouseReleaseEvent(QGraphicsSceneMouseEvent *event) override;
protected:
bool is_movable_{true};
bool m_first_move{true};
bool snap_to_grid_{true};
QPointF m_mouse_to_origin_movement{QPointF(0,0)};
bool is_movable_;
bool m_first_move;
bool snap_to_grid_;
QPointF m_mouse_to_origin_movement;
QET::GraphicsItemState m_state = QET:: GIOK;
};

5
sources/qetgraphicsitem/qetshapeitem.cpp
View File

@@ -663,7 +663,7 @@ void QetShapeItem::insertPoint()
if(new_polygon != m_polygon)
{
//Wrap the undo for avoid to merge the undo commands when user add several points.
QUndoCommand *undo = new QUndoCommand(tr("Ajouter un point ?? un polygone"));
QUndoCommand *undo = new QUndoCommand(tr("Ajouter un point à un polygone"));
new QPropertyUndoCommand(this, "polygon", m_polygon, new_polygon, undo);
diagram()->undoStack().push(undo);
}
@@ -836,7 +836,6 @@ void QetShapeItem::handlerMouseReleaseEvent()
}
}
// TODO: inherit from Propertiesinterface!
/**
@brief QetShapeItem::fromXml
Build this item from the xml description
@@ -998,7 +997,7 @@ QString QetShapeItem::name() const
switch (m_shapeType) {
case Line: return tr("une ligne");
case Rectangle: return tr("un rectangle");
case Ellipse: return tr("une ??llipse");
case Ellipse: return tr("une éllipse");
case Polygon: return tr("une polyligne");
default: return tr("une shape");
}

2
sources/qetgraphicsitem/slaveelement.h
View File

@@ -35,7 +35,7 @@ class SlaveElement : public Element
void unlinkElement(Element *elmt) override;
private:
QGraphicsTextItem *m_xref_item{nullptr};
QGraphicsTextItem *m_xref_item;
};
#endif // SLAVEELEMENT_H

199
sources/qetgraphicsitem/terminal.cpp
View File

@@ -25,8 +25,6 @@
#include "../qetgraphicsitem/element.h"
#include "conductortextitem.h"
#include "../qetxml.h"
#include <utility>
QColor Terminal::neutralColor = QColor(Qt::blue);
@@ -43,7 +41,7 @@ const qreal Terminal::Z = 1000;
@param name of terminal
@param hiddenName
*/
void Terminal::init(QString number, QString name, bool hiddenName)
void Terminal::init()
{
//Calcul the docking point of the element
//m_pos of d is the docking point of conductor
@@ -66,104 +64,19 @@ void Terminal::init(QString number, QString name, bool hiddenName)
qreal h = qAbs(dcy - dey) + 7;
m_br = QRectF(origin, QSizeF(w, h));
// Number of terminal
number_terminal_ = std::move(number);
// Name of terminal
d->m_name = std::move(name);
name_terminal_hidden = hiddenName;
setAcceptHoverEvents(true);
setAcceptedMouseButtons(Qt::LeftButton);
setToolTip(QObject::tr("Borne", "tooltip"));
setZValue(Z);
}
/*!
\brief Terminal::init
Additionaly to the init above, this method stores position and orientation into the data class
\param pf
\param o
\param number
\param name
\param hiddenName
*/
void Terminal::init(
QPointF pf,
Qet::Orientation o,
QString number,
QString name,
bool hiddenName)
{
setTagName("terminal");
// definition du pount d'amarrage pour un conducteur
d->m_pos = pf;
// definition de l'orientation de la borne (par defaut : sud)
if (o < Qet::North || o > Qet::West) d->m_orientation = Qet::South;
else d->m_orientation = o;
init(number, name, hiddenName);
}
/**
initialise une borne
@param pf position du point d'amarrage pour un conducteur
@param o orientation de la borne : Qt::Horizontal ou Qt::Vertical
@param e Element auquel cette borne appartient
*/
Terminal::Terminal(QPointF pf, Qet::Orientation o, Element *e) :
QGraphicsObject(e),
d(new TerminalData(this)),
parent_element_ (e)
{
init(pf, o, "_", "_", false);
}
/**
initialise une borne
@param pf_x Abscisse du point d'amarrage pour un conducteur
@param pf_y Ordonnee du point d'amarrage pour un conducteur
@param o orientation de la borne : Qt::Horizontal ou Qt::Vertical
@param e Element auquel cette borne appartient
*/
Terminal::Terminal(qreal pf_x, qreal pf_y, Qet::Orientation o, Element *e) :
QGraphicsObject(e),
d(new TerminalData(this)),
parent_element_ (e)
{
init(QPointF(pf_x, pf_y), o, "_", "_", false);
}
/**
initialise une borne
@param pf position du point d'amarrage pour un conducteur
@param o orientation de la borne : Qt::Horizontal ou Qt::Vertical
@param num number of terminal (ex 3 - 4 for NO)
@param name of terminal
@param hiddenName hide or show the name
@param e Element auquel cette borne appartient
*/
Terminal::Terminal(
QPointF pf,
Qet::Orientation o,
QString num,
QString name,
bool hiddenName,
Element *e) :
QGraphicsObject (e),
d(new TerminalData(this)),
parent_element_ (e)
{
init(pf, o, std::move(num), std::move(name), hiddenName);
}
Terminal::Terminal(TerminalData* data, Element* e) :
QGraphicsObject(e),
d(data),
parent_element_(e)
{
d->setParent(this);
init("_", "_", false);
init();
}
/**
@@ -197,34 +110,6 @@ Qet::Orientation Terminal::orientation() const
} else return(d->m_orientation);
}
/**
@brief Terminal::setNumber
@param number
*/
void Terminal::setNumber(QString number)
{
number_terminal_ = std::move(number);
}
/**
@brief Terminal::setName
@param name : QString
@param hiddenName : bool
*/
void Terminal::setName(QString name, bool hiddenName)
{
d->m_name = std::move(name);
name_terminal_hidden = hiddenName;
}
/**
@brief Terminal::name
@return the name of terminal.
*/
inline QString Terminal::name() const {
return(d->m_name);
}
/**
@brief Terminal::addConductor
Add a conductor to this terminal
@@ -739,10 +624,6 @@ bool Terminal::canBeLinkedTo(Terminal *other_terminal)
return true;
}
void Terminal::setID(int id) {
m_id = id;
}
/**
@brief Terminal::conductors
@return La liste des conducteurs lies a cette borne
@@ -753,19 +634,22 @@ QList<Conductor *> Terminal::conductors() const
}
/**
@brief Terminal::toXmlPriv
@brief Terminal::toXml
Methode d'export en XML
@param doc Le Document XML a utiliser pour creer l'element XML
@return un QDomElement representant cette borne
*/
void Terminal::toXmlPriv(QDomElement &qdo) const
QDomElement Terminal::toXml(QDomDocument &doc) const
{
QDomElement qdo = doc.createElement("terminal");
// for backward compatibility
qdo.setAttribute("x", QString("%1").arg(dock_elmt_.x()));
qdo.setAttribute("y", QString("%1").arg(dock_elmt_.y()));
// end for backward compatibility
qdo.setAttribute("orientation", d->m_orientation);
return(qdo);
}
/**
@@ -774,25 +658,42 @@ void Terminal::toXmlPriv(QDomElement &qdo) const
@param terminal Le QDomElement a analyser
@return true si le QDomElement passe en parametre est une borne, false sinon
*/
bool Terminal::valideXml(const QDomElement &terminal)
bool Terminal::valideXml(QDomElement &terminal)
{
// verifie le nom du tag
if (terminal.tagName() != "terminal") return(false);
// affuteuse_250h.qet contains in line 8398 terminals which do not have this
// if (QETXML::propertyString(terminal, "number"))
// return false;
// affuteuse_250h.qet contains in line 8398 terminals which do not have this
// if (QETXML::propertyBool(terminal, "nameHidden"))
// return false;
// verifie la presence des attributs minimaux
if (!terminal.hasAttribute("x")) return(false);
if (!terminal.hasAttribute("y")) return(false);
if (!terminal.hasAttribute("orientation")) return(false);
if (!TerminalData::valideXml(terminal))
return false;
bool conv_ok;
// parse l'abscisse
terminal.attribute("x").toDouble(&conv_ok);
if (!conv_ok) return(false);
// parse l'ordonnee
terminal.attribute("y").toDouble(&conv_ok);
if (!conv_ok) return(false);
// parse l'id
terminal.attribute("id").toInt(&conv_ok);
if (!conv_ok) return(false);
// parse l'orientation
int terminal_or = terminal.attribute("orientation").toInt(&conv_ok);
if (!conv_ok) return(false);
if (terminal_or != Qet::North
&& terminal_or != Qet::South
&& terminal_or != Qet::East
&& terminal_or != Qet::West) return(false);
// a ce stade, la borne est syntaxiquement correcte
return true;
return(true);
}
/** RETURNS True
/**
@brief Terminal::fromXml
Permet de savoir si un element XML represente cette borne. Attention,
l'element XML n'est pas verifie
@@ -800,17 +701,13 @@ bool Terminal::valideXml(const QDomElement &terminal)
@return true si la borne "se reconnait"
(memes coordonnes, meme orientation), false sinon
*/
bool Terminal::fromXmlPriv(const QDomElement &terminal) {
QETXML::propertyString(terminal, "number", &number_terminal_);
QETXML::propertyBool(terminal, "nameHidden", &name_terminal_hidden);
if(!d->fromXml(terminal))
return false;
init(number_terminal_, d->m_name, name_terminal_hidden); // initialize dock_elmt_. This must be done after Terminal data is initialized
return true;
bool Terminal::fromXml(QDomElement &terminal)
{
return (
qFuzzyCompare(terminal.attribute("x").toDouble(), dock_elmt_.x()) &&
qFuzzyCompare(terminal.attribute("y").toDouble(), dock_elmt_.y()) &&
(terminal.attribute("orientation").toInt() == d->m_orientation)
);
}
/**
@@ -847,18 +744,6 @@ QUuid Terminal::uuid() const
return d->m_uuid;
}
int Terminal::ID() const {
return m_id;
}
QPointF Terminal::dockPos() {
return dock_elmt_;
}
QPointF Terminal::originPos() {
return d->m_pos;
}
/**
@brief Conductor::relatedPotentialTerminal
Return terminal at the same potential from the same

61
sources/qetgraphicsitem/terminal.h
View File

@@ -21,9 +21,6 @@
#include <QtWidgets>
#include <QtXml>
#include "../qet.h"
#include "../properties/propertiesinterface.h"
class Conductor;
class Diagram;
class Element;
@@ -35,7 +32,7 @@ class TerminalData;
plug point for conductors.
This class handles all mouse events for connecting conductors
*/
class Terminal : public QGraphicsObject, public PropertiesInterface
class Terminal : public QGraphicsObject
{
Q_OBJECT
@@ -45,11 +42,7 @@ class Terminal : public QGraphicsObject, public PropertiesInterface
// constructors, destructor
public:
Terminal(QPointF, Qet::Orientation, Element * = nullptr);
Terminal(qreal, qreal, Qet::Orientation, Element * = nullptr);
Terminal(TerminalData* data, Element *e = nullptr);
Terminal(QPointF, Qet::Orientation, QString number,
QString name, bool hiddenName, Element * = nullptr);
~Terminal() override;
private:
@@ -81,14 +74,6 @@ class Terminal : public QGraphicsObject, public PropertiesInterface
Diagram *diagram () const;
Element *parentElement () const;
QUuid uuid () const;
int ID() const;
QPointF dockPos();
QPointF originPos();
QString number() const;
void setNumber(QString number);
void setName(QString name, bool hiddenName);
QString name() const;
QList<Conductor *> conductors() const;
Qet::Orientation orientation() const;
@@ -96,15 +81,11 @@ class Terminal : public QGraphicsObject, public PropertiesInterface
void updateConductor();
bool isLinkedTo(Terminal *);
bool canBeLinkedTo(Terminal *);
void setID(int id);
// methods related to XML import/export
static bool valideXml(const QDomElement &);
bool fromXmlPriv (const QDomElement &) override;
void toXmlPriv(QDomElement &) const override;
void toSettings(QSettings &,const QString & = QString()) const override {/*TODO: implement*/}
void fromSettings(QSettings &,const QString & = QString()) override{/*TODO: implement*/}
static bool valideXml(QDomElement &);
bool fromXml (QDomElement &);
QDomElement toXml (QDomDocument &) const;
protected:
// methods related to events management
@@ -122,7 +103,6 @@ class Terminal : public QGraphicsObject, public PropertiesInterface
static const qreal terminalSize;
static const qreal Z;
// Various static colors used for hover effects
// The assignement is in the cpp file
/// default color
static QColor neutralColor;
/// color for legal actions
@@ -138,7 +118,7 @@ class Terminal : public QGraphicsObject, public PropertiesInterface
QGraphicsLineItem *m_help_line_a{nullptr};
TerminalData* d{nullptr};
TerminalData* d;
/// Parent electrical element
Element *parent_element_{nullptr};
@@ -148,28 +128,17 @@ class Terminal : public QGraphicsObject, public PropertiesInterface
private:
/// List of conductors attached to the terminal
QList<Conductor *> m_conductors_list;
/**
Pointer to a rectangle representing the terminal bounding rect;
used to calculate the bounding rect once only;
used a pointer because boundingRect() is supposed to be const.
*/
QRectF m_br;
/// Last terminal seen through an attached conductor
Terminal *m_previous_terminal{nullptr};
Terminal *m_previous_terminal = nullptr;
/// Whether the mouse pointer is hovering the terminal
bool m_hovered{false};
bool m_hovered = false;
/// Color used for the hover effect
QColor m_hovered_color{Terminal::neutralColor};
/// Number of Terminal
QString number_terminal_;
bool name_terminal_hidden{true};
/// legacy id used by the conductor to find the terminal. From 0.8x on the uuid is used instead.
int m_id{-1};
QColor m_hovered_color = Terminal::neutralColor;
private:
void init(QString number, QString name, bool hiddenName);
void init(QPointF pf, Qet::Orientation o,QString number, QString name, bool hiddenName);
void init();
void init(QPointF pf, Qet::Orientation o);
};
/**
@@ -181,16 +150,6 @@ inline int Terminal::conductorsCount() const
return(m_conductors_list.size());
}
/**
@brief Terminal::number
@return the number of terminal.
*/
inline QString Terminal::number() const
{
return(number_terminal_);
}
QList<Terminal *> relatedPotentialTerminal (const Terminal *terminal,
const bool all_diagram = true);

20
sources/qetproject.cpp
View File

@@ -39,8 +39,6 @@
#include <QtDebug>
#include <utility>
#include "qetxml.h"
static int BACKUP_INTERVAL = 120000; //interval in ms of backup = 2min
/**
@@ -1534,11 +1532,7 @@ void QETProject::readDefaultPropertiesXml(QDomDocument &xml_project)
{
XRefProperties xrp;
xrp.fromXml(elmt);
QString type;
if (QETXML::propertyString(elmt, "type", &type) == QETXML::PropertyFlags::Success)
m_default_xref_properties.insert(type, xrp);
else
qDebug() << "xref Property was not added to m_default_xref_properties.";
m_default_xref_properties.insert(elmt.attribute("type"), xrp);
}
}
if (!conds_autonums.isNull())
@@ -1596,13 +1590,19 @@ void QETProject::writeDefaultPropertiesXml(QDomElement &xml_element)
QDomDocument xml_document = xml_element.ownerDocument();
// export size of border
xml_element.appendChild(default_border_properties_.toXml(xml_document));
QDomElement border_elmt = xml_document.createElement("border");
default_border_properties_.toXml(border_elmt);
xml_element.appendChild(border_elmt);
// export content of titleblock
xml_element.appendChild(default_titleblock_properties_.toXml(xml_document));
QDomElement titleblock_elmt = xml_document.createElement("inset");
default_titleblock_properties_.toXml(titleblock_elmt);
xml_element.appendChild(titleblock_elmt);
// exporte default conductor
xml_element.appendChild(default_conductor_properties_.toXml(xml_document));
QDomElement conductor_elmt = xml_document.createElement("conductors");
default_conductor_properties_.toXml(conductor_elmt);
xml_element.appendChild(conductor_elmt);
// export default report properties
QDomElement report_elmt = xml_document.createElement("report");

296
sources/qetxml.cpp
View File

@@ -581,299 +581,3 @@ QVector<QDomElement> QETXML::findInDomElement(const QDomElement &dom_elmt, const
}
return(return_list);
}
namespace QETXML {
PropertyFlags debugReadXml(PropertyFlags flag, const QDomElement &e, const QString& attribute_name, const QString& attr, const QString& type)
{
if (flag == QETXML::PropertyFlags::NoValidConversion)
qDebug() << "\t\t\t" << "Tagname: " << e.tagName() << ". " << "No valid Conversion: " << attribute_name << ". type: " << type << ". value: " << attr;
return flag;
}
QDomElement createXmlProperty(const QString& name, const QString value) {
QDomDocument doc;
QDomElement p = doc.createElement("property");
p.setAttribute("name", name);
p.setAttribute("type", stringS);
p.setAttribute("value", value);
return p;
}
QDomElement createXmlProperty(const QString& name, const char* value) {
QDomDocument doc;
QDomElement p = doc.createElement("property");
p.setAttribute("name", name);
p.setAttribute("type", stringS);
p.setAttribute("value", value);
return p;
}
/*!
* \brief propertyInteger
* Reads an interger from the XML element.
* \param e DomElement which contains the property attribute
* \param attribute_name Name of the attribute
* \param entier Return value if success
* \return True if reading an integer was successful, else False. If the attribute was not found,
* \p entier is not valid and the return value is False
*/
QDomElement createXmlProperty(const QString& name, const int value) {
QDomDocument doc;
QDomElement p = doc.createElement("property");
p.setAttribute("name", name);
p.setAttribute("type", integerS);
p.setAttribute("value", QString::number(value));
return p;
}
QDomElement createXmlProperty(const QString& name, const double value) {
QDomDocument doc;
QDomElement p = doc.createElement("property");
p.setAttribute("name", name);
p.setAttribute("type", doubleS);
p.setAttribute("value", QString::number(value));
return p;
}
QDomElement createXmlProperty(const QString& name, const bool value) {
QDomDocument doc;
QDomElement p = doc.createElement("property");
p.setAttribute("name", name);
p.setAttribute("type", boolS);
p.setAttribute("value", QString::number(value));
return p;
}
QDomElement createXmlProperty(const QString& name, const QUuid value) {
QDomDocument doc;
QDomElement p = doc.createElement("property");
p.setAttribute("name", name);
p.setAttribute("type", uuidS);
p.setAttribute("value", value.toString());
return p;
}
QDomElement createXmlProperty(const QString& name, const QColor value) {
QDomDocument doc;
QDomElement p = doc.createElement("property");
p.setAttribute("name", name);
p.setAttribute("type", colorS);
p.setAttribute("value", value.name());
return p;
}
/*!
* \brief PropertiesInterface::propertyInteger
* Reads an interger from the XML element.
* \param e DomElement which contains the property attribute
* \param attribute_name Name of the attribute
* \param entier Return value if success
* \return True if reading an integer was successful, else False. If the attribute was not found,
* \p entier is not valid and the return value is False
*/
PropertyFlags propertyInteger(const QDomElement &e, const QString& attribute_name, int* entier) {
QString attr;
if (!attribute(e, attribute_name, integerS, &attr)) {
return PropertyFlags::NotFound;
}
return debugReadXml(propertyInteger(attr, entier), e, attribute_name, attr, integerS);
}
PropertyFlags propertyInteger(const QString& value, int* entier) {
// verifie la validite de l'attribut
bool ok;
int tmp = value.toInt(&ok);
if (!ok) {
return QETXML::PropertyFlags::NoValidConversion;
}
if (entier != nullptr)
*entier = tmp;
return PropertyFlags::Success;
}
PropertyFlags propertyDouble(const QDomElement &e, const QString& attribute_name, double* reel) {
QString attr;
if (!attribute(e, attribute_name, doubleS, &attr)) {
return PropertyFlags::NotFound;
}
return debugReadXml(propertyDouble(attr, reel), e, attribute_name, attr, doubleS);
}
PropertyFlags propertyDouble(const QString& value, double* reel)
{
// verifie la validite de l'attribut
bool ok;
double tmp = value.toDouble(&ok);
if (!ok) {
return QETXML::PropertyFlags::NoValidConversion;
}
if (reel != nullptr)
*reel = tmp;
return PropertyFlags::Success;
}
PropertyFlags propertyBool(const QDomElement &e, const QString& attribute_name, bool* boolean) {
QString attr;
if (!attribute(e, attribute_name, boolS, &attr)) {
return PropertyFlags::NotFound;
}
return debugReadXml(propertyBool(attr, boolean), e, attribute_name, attr, boolS);
}
PropertyFlags propertyBool(const QString& value, bool* boolean)
{
// verifie la validite de l'attribut
bool ok;
bool tmp = value.toInt(&ok);
if (!ok) {
if (value == "true" || value == "1")
tmp = true;
else if (value == "false" || value == "0")
tmp = false;
else {
return QETXML::PropertyFlags::NoValidConversion;
}
}
if (boolean != nullptr)
*boolean = tmp;
return PropertyFlags::Success;
}
PropertyFlags propertyColor(const QDomElement &e, const QString& attribute_name, QColor* color) {
QString attr;
if (!attribute(e, attribute_name, colorS, &attr)) {
return PropertyFlags::NotFound;
}
return debugReadXml(propertyColor(attr, color), e, attribute_name, attr, colorS);
}
PropertyFlags propertyColor(const QString& value, QColor* color)
{
// verifie la validite de l'attribut
QColor tmp = QColor(value);
if (!tmp.isValid()) {
return QETXML::PropertyFlags::NoValidConversion;
}
if (color != nullptr)
*color = tmp;
return PropertyFlags::Success;
}
PropertyFlags propertyUuid(const QDomElement &e, const QString& attribute_name, QUuid* uuid) {
QString attr;
if (!attribute(e, attribute_name, uuidS, &attr)) {
return PropertyFlags::NotFound;
}
return debugReadXml(propertyUuid(attr, uuid), e, attribute_name, attr, uuidS);
}
PropertyFlags propertyUuid(const QString& value, QUuid* uuid)
{
if (QUuid(value).isNull()){
return QETXML::PropertyFlags::NoValidConversion;
}
if (uuid != nullptr)
*uuid = QUuid(value);
return PropertyFlags::Success;
}
PropertyFlags propertyString(const QDomElement& e, const QString& attribute_name, QString* string) {
QString attr;
if (!attribute(e, attribute_name, stringS, &attr)) {
return PropertyFlags::NotFound;
}
// verifie la validite de l'attribut
if (string != nullptr)
*string = attr;
return PropertyFlags::Success;
}
QDomElement property(const QDomElement& e, const QString& name) {
for (int i=0; i < e.childNodes().count(); i++) {
QDomElement child = e.childNodes().at(i).toElement();
if (!validXmlProperty(child))
continue; // there might also non property childs
if (child.attribute("name") == name)
return child;
}
return QDomElement();
}
/*!
* \brief PropertiesInterface::attribute
* Returns the property with the name \p attribute_name and type \p type
* \param e Xml element which contains the property
* \param attribute_name
* \param type Type of the property
* \param attr
* \return
*/
bool attribute(const QDomElement& e, const QString& attribute_name, const QString& type, QString* attr) {
QDomElement p = property(e, attribute_name);
if (p.isNull()) {
// check if legacy property is available,
// where the property is inside the element as attribute
if (!e.hasAttribute(attribute_name)) {
qDebug() << "\t\t\t" << "Tagname: " << e.tagName() << ". " << "Property " << attribute_name << "is not available";
return false;
}
*attr = e.attribute(attribute_name);
} else {
if (p.attribute("type") != type) {
qDebug() << "\t\t\t" << "Tagname: " << e.tagName() << ", Property: " << attribute_name << "(" << p.attribute("type") << ") has not type: " << type;
return false;
}
*attr = p.attribute("value");
}
return true;
}
bool validXmlProperty(const QDomElement& e) {
if (!e.hasAttribute("name"))
return false;
if (!e.hasAttribute("type"))
return false;
if (!e.hasAttribute("value"))
return false;
return true;
}
}

48
sources/qetxml.h
View File

@@ -89,54 +89,6 @@ namespace QETXML
QVector<QDomElement> findInDomElement(const QDomElement &dom_elmt,
const QString &tag_name);
const QString integerS = "int";
const QString doubleS = "double";
const QString boolS = "bool";
const QString stringS = "string";
const QString uuidS = "uuid";
const QString colorS = "color";
enum PropertyFlags {
Success = 0,
NotFound = 1,
NoValidConversion = 2,
// = 4
};
/*!
* Use this functions to add properties to the xml document
*/
QDomElement createXmlProperty(const QString& name, const QString value);
QDomElement createXmlProperty(const QString& name, const char* value);
QDomElement createXmlProperty(const QString& name, const int value);
QDomElement createXmlProperty(const QString& name, const double value);
QDomElement createXmlProperty(const QString& name, const bool value);
QDomElement createXmlProperty(const QString& name, const QUuid value);
QDomElement createXmlProperty(const QString& name, const QColor value);
PropertyFlags propertyInteger(const QString& value, int* entry = nullptr);
PropertyFlags propertyInteger(const QDomElement &e, const QString& attribute_name, int *entier = nullptr);
PropertyFlags propertyDouble(const QString& value, double* entry = nullptr);
PropertyFlags propertyDouble(const QDomElement &e, const QString& attribute_name, double *reel = nullptr);
PropertyFlags propertyString(const QDomElement& e, const QString& attribute_name, QString* string = nullptr);
PropertyFlags propertyBool(const QString& value, bool* entry = nullptr);
PropertyFlags propertyBool(const QDomElement &e, const QString& attribute_name, bool* boolean = nullptr);
PropertyFlags propertyUuid(const QString& value, QUuid* entry = nullptr);
PropertyFlags propertyUuid(const QDomElement &e, const QString& attribute_name, QUuid* uuid = nullptr);
PropertyFlags propertyColor(const QString& value, QColor* entry = nullptr);
PropertyFlags propertyColor(const QDomElement &e, const QString& attribute_name, QColor* color = nullptr);
QDomElement property(const QDomElement& e, const QString& name);
bool attribute(const QDomElement& e, const QString& attribute_name, const QString& type, QString* attr);
/*!
* \brief PropertiesInterface::validXmlProperty
* Check if the Xml element contains the needed fields
* \param e Xml Property
* \return True if name, type, value attribute are available, else false
*/
bool validXmlProperty(const QDomElement& e);
}
#endif // QETXML_H

8
sources/titleblock/helpercell.h
View File

@@ -38,11 +38,11 @@ class HelperCell : public QGraphicsObject, public QGraphicsLayoutItem {
// attributes
public:
QColor background_color{Qt::white}; ///< Background color when rendering this cell
QColor foreground_color{Qt::black}; ///< Text color when rendering this cell
QColor background_color; ///< Background color when rendering this cell
QColor foreground_color; ///< Text color when rendering this cell
QString label; ///< Label displayed in this cell
Qt::Orientation orientation{Qt::Horizontal}; ///< Orientation of this cell
int index{-1}; ///< Index of this cell
Qt::Orientation orientation; ///< Orientation of this cell
int index; ///< Index of this cell
// methods
public:

1
sources/titleblock/splittedhelpercell.h
View File

@@ -36,7 +36,6 @@ class SplittedHelperCell : public HelperCell {
void paint(QPainter *, const QStyleOptionGraphicsItem *, QWidget * = nullptr) override;
// attributes
// colors are set in the constructor
QColor split_background_color; ///< Background color on the split side
QColor split_foreground_color; ///< Text color on the split side
QString split_label; ///< Text displayed on the split side

55
sources/titleblockproperties.cpp
View File

@@ -19,15 +19,16 @@
#include "qet.h"
#include "qetapp.h"
#include "qetxml.h"
/**
Constructeur. Initialise un objet TitleBlockProperties avec tous les champs
vides (date vide + useDate a UseDateValue).
*/
TitleBlockProperties::TitleBlockProperties()
TitleBlockProperties::TitleBlockProperties() :
date(),
useDate(UseDateValue),
display_at(Qt::BottomEdge),
collection (QET::QetCollection::Common)
{
setTagName("titleblock");
}
/**
@@ -68,11 +69,13 @@ bool TitleBlockProperties::operator!=(const TitleBlockProperties &ip) {
return(!(*this == ip));
}
/**
Exporte le cartouche sous formes d'attributs XML ajoutes a l'element e.
@param e Element XML auquel seront ajoutes des attributs
*/
void TitleBlockProperties::toXmlPriv(QDomElement& e) const {
void TitleBlockProperties::toXml(QDomElement &e) const
{
e.setAttribute("author", author);
e.setAttribute("title", title);
e.setAttribute("filename", filename);
@@ -97,36 +100,29 @@ void TitleBlockProperties::toXmlPriv(QDomElement& e) const {
}
}
/** RETURNS True
/**
Importe le cartouche a partir des attributs XML de l'element e
@param e Element XML dont les attributs seront lus
*/
bool TitleBlockProperties::fromXmlPriv(const QDomElement &e) {
void TitleBlockProperties::fromXml(const QDomElement &e) {
// reads the historical fields
QETXML::propertyString(e, "author", &author);
QETXML::propertyString(e, "title", &title);
QETXML::propertyString(e, "filename", &filename);
QETXML::propertyString(e, "plant", &plant);
QETXML::propertyString(e, "locmach", &locmach);
QETXML::propertyString(e, "indexrev", &indexrev);
QETXML::propertyString(e, "version", &version);
QETXML::propertyString(e, "folio", &folio);
QETXML::propertyString(e, "auto_page_num", &auto_page_num);
QString date;
QETXML::propertyString(e, "date", &date);
setDateFromString(date);
QString display_at_temp;
if (QETXML::propertyString(e, "displayAt", &display_at_temp) == QETXML::PropertyFlags::Success)
display_at = (display_at_temp == "bottom" ? Qt::BottomEdge : Qt::RightEdge); // otherwise it gets default in header file
if (e.hasAttribute("author")) author = e.attribute("author");
if (e.hasAttribute("title")) title = e.attribute("title");
if (e.hasAttribute("filename")) filename = e.attribute("filename");
if (e.hasAttribute("plant")) plant = e.attribute("plant");
if (e.hasAttribute("locmach")) locmach = e.attribute("locmach");
if (e.hasAttribute("indexrev")) indexrev = e.attribute("indexrev");
if (e.hasAttribute("version")) version = e.attribute("version");
if (e.hasAttribute("folio")) folio = e.attribute("folio");
if (e.hasAttribute("auto_page_num")) auto_page_num = e.attribute("auto_page_num");
if (e.hasAttribute("date")) setDateFromString(e.attribute("date"));
if (e.hasAttribute("displayAt")) display_at = (e.attribute("displayAt") == "bottom" ? Qt::BottomEdge : Qt::RightEdge);
// reads the template used to render the title block
if (QETXML::propertyString(e, "titleblocktemplate", &template_name) == QETXML::PropertyFlags::Success) {
QString tbc;
if (QETXML::propertyString(e, "titleblocktemplateCollection", &tbc) == QETXML::PropertyFlags::Success)
collection = QET::qetCollectionFromString(tbc);
if (e.hasAttribute("titleblocktemplate"))
{
template_name = e.attribute("titleblocktemplate");
collection = QET::qetCollectionFromString(e.attribute("titleblocktemplateCollection"));
}
// reads the additional fields used to fill the title block
@@ -134,7 +130,6 @@ bool TitleBlockProperties::fromXmlPriv(const QDomElement &e) {
foreach (QDomElement e, QET::findInDomElement(e, "properties")) {
context.fromXml(e);
}
return true;
}
/**

18
sources/titleblockproperties.h
View File

@@ -21,14 +21,12 @@
#include "diagramcontext.h"
#include "qet.h"
#include "properties/propertiesinterface.h"
/**
This class provides a container for the properties of a particular title
block, i.e. title, author, date, filename, folio, template, custom
properties, ...
*/
class TitleBlockProperties: public PropertiesInterface {
class TitleBlockProperties {
public:
TitleBlockProperties();
virtual ~TitleBlockProperties();
@@ -41,10 +39,10 @@ class TitleBlockProperties: public PropertiesInterface {
bool operator==(const TitleBlockProperties &);
bool operator!=(const TitleBlockProperties &);
void toXmlPriv(QDomElement &e) const override;
bool fromXmlPriv(const QDomElement &) override;
void toSettings(QSettings &, const QString & = QString()) const override;
void fromSettings(QSettings &, const QString & = QString()) override;
void toXml(QDomElement &) const;
void fromXml(const QDomElement &);
void toSettings(QSettings &, const QString & = QString()) const;
void fromSettings(QSettings &, const QString & = QString());
void setAutoPageNum(QString autonum) {auto_page_num = autonum;}
@@ -63,11 +61,11 @@ class TitleBlockProperties: public PropertiesInterface {
QString version; ///< Version (displayed by the default template)
QString folio; ///< Folio information (displayed by the default template)
QString auto_page_num;
DateManagement useDate{UseDateValue}; ///< Wheter to use the date attribute
DateManagement useDate; ///< Wheter to use the date attribute
QString template_name; ///< Name of the template used to render the title block - an empty string means "the default template provided by the application"
DiagramContext context; ///< Container for the additional, user-defined fields
Qt::Edge display_at{Qt::Edge::BottomEdge}; ///< Edge to display the titleblock
QET::QetCollection collection{QET::QetCollection::Common}; ///<Specify the location of the title block
Qt::Edge display_at; ///< Edge to display the titleblock
QET::QetCollection collection; ///<Specify the location of the title block
private:
QString exportDate() const;