SHS/qad
4
1
Fork 0
Code Issues 5 Pull Requests Releases Wiki Activity

moved to shstk

Browse Source
This commit is contained in:
Пелипенко Иван
2020-08-25 22:24:02 +03:00
parent d4f1c78a6e
commit b92a1fa558
904 changed files with 2448 additions and 36452 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
libs/piqt/CMakeLists.txt Normal file
View File

@@ -0,0 +1 @@
piqt_library(piqt "Gui;Positioning" "qad_utils;qad_widgets")

141
libs/piqt/piqt.cpp Normal file
View File

@@ -0,0 +1,141 @@
#include "piqt.h"
#include "qvariantedit.h"
#if QT_VERSION >= 0x050200
# include <QGeoCoordinate>
#endif
const QAD::Enum PI2QADEnum(const PIVariantTypes::Enum & el) {
QAD::Enum ret;
piForeachC (PIVariantTypes::Enumerator & e, el.enum_list)
ret << QAD::Enumerator(e.value, PI2QString(e.name));
ret.selectValue(el.selectedValue());
return ret;
}
const PIVariantTypes::Enum QAD2PIEnum(const QAD::Enum & el) {
PIVariantTypes::Enum ret;
foreach (const QAD::Enumerator & e, el.enum_list)
ret << PIVariantTypes::Enumerator(e.value, Q2PIString(e.name));
ret.selectValue(el.selectedValue());
return ret;
}
const QVariant PI2QVariant(const PIVariant & v) {
switch (v.type()) {
case PIVariant::pivBool: return QVariant(v.toBool());
case PIVariant::pivChar:
case PIVariant::pivUChar:
case PIVariant::pivShort:
case PIVariant::pivUShort:
case PIVariant::pivInt: return QVariant(v.toInt());
case PIVariant::pivUInt: return QVariant(uint(v.toInt()));
case PIVariant::pivLLong: return QVariant(v.toLLong());
case PIVariant::pivULLong: return QVariant(ullong(v.toLLong()));
case PIVariant::pivFloat: return QVariant(v.toFloat());
case PIVariant::pivDouble: return QVariant(v.toDouble());
case PIVariant::pivLDouble: return QVariant(v.toDouble());
case PIVariant::pivByteArray: return QVariant(PI2QByteArray(v.toByteArray()));
case PIVariant::pivString: return QVariant(PI2QString(v.toString()));
case PIVariant::pivStringList: return QVariant(PI2QStringList(v.toStringList()));
case PIVariant::pivTime: return QVariant(PI2QTime(v.toTime()));
case PIVariant::pivDate: return QVariant(PI2QDate(v.toDate()));
case PIVariant::pivDateTime: return QVariant(PI2QDateTime(v.toDateTime()));
case PIVariant::pivEnum: return QVariant::fromValue(PI2QADEnum(v.toEnum()));
case PIVariant::pivFile: return QVariant::fromValue(PI2QADFile(v.toFile()));
case PIVariant::pivDir: return QVariant::fromValue(PI2QADDir(v.toDir()));
case PIVariant::pivColor: return QVariant::fromValue(PI2QColor(v.toColor()));
case PIVariant::pivPoint: return QVariant(PI2QPoint(v.toPoint()));
case PIVariant::pivRect: return QVariant(PI2QRect(v.toRect()));
case PIVariant::pivIODevice: return QVariant::fromValue(PI2QADIODevice(v.toIODevice()));
case PIVariant::pivMathVector: return QVariant::fromValue(PI2QMathVector(v.toMathVector()));
case PIVariant::pivMathMatrix: return QVariant::fromValue(PI2QMathMatrix(v.toMathMatrix()));
//case PIVariant::pivSystemTime: return QVariant(v.to());
default: return QVariant();
}
return QVariant();
}
const PIVariant Q2PIVariant(const QVariant & v) {
switch (v.type()) {
case QVariant::Bool: return PIVariant(v.toBool());
case QVariant::Int: return PIVariant(v.toInt());
case QVariant::UInt: return PIVariant(v.toUInt());
case QVariant::LongLong: return PIVariant(v.toLongLong());
case QVariant::ULongLong: return PIVariant(v.toULongLong());
case QVariant::Double: return PIVariant(v.toDouble());
case QVariant::ByteArray: return PIVariant(Q2PIByteArray(v.toByteArray()));
case QVariant::String: return PIVariant(Q2PIString(v.toString()));
case QVariant::StringList: return PIVariant(Q2PIStringList(v.toStringList()));
case QVariant::Time: return PIVariant(Q2PITime(v.toTime()));
case QVariant::Date: return PIVariant(Q2PIDate(v.toDate()));
case QVariant::DateTime: return PIVariant(Q2PIDateTime(v.toDateTime()));
case QVariant::Color: return PIVariant(Q2PIColor(v.value<QColor>()));
case QVariant::Point:
case QVariant::PointF: return PIVariant(Q2PIPoint(v.toPointF()));
case QVariant::Rect:
case QVariant::RectF: return PIVariant(Q2PIRect(v.toRectF()));
default: break;
}
if (v.canConvert<QAD::Enum>()) return PIVariant(QAD2PIEnum(v.value<QAD::Enum>()));
if (v.canConvert<QAD::File>()) return PIVariant(QAD2PIFile(v.value<QAD::File>()));
if (v.canConvert<QAD::Dir>()) return PIVariant(QAD2PIDir(v.value<QAD::Dir>()));
if (v.canConvert<QAD::IODevice>()) return PIVariant(QAD2PIIODevice(v.value<QAD::IODevice>()));
if (v.canConvert<QAD::MathVector>()) return PIVariant(Q2PIMathVector(v.value<QAD::MathVector>()));
if (v.canConvert<QAD::MathMatrix>()) return PIVariant(Q2PIMathMatrix(v.value<QAD::MathMatrix>()));
return PIVariant();
}
const PIVariantTypes::IODevice QAD2PIIODevice(const QAD::IODevice & v) {
PIVariantTypes::IODevice d;
d.set(Q2PIPropertyStorage(v.props));
d.prefix = Q2PIString(v.prefix);
d.mode = v.mode;
d.options = v.options;
return d;
}
const QAD::IODevice PI2QADIODevice(const PIVariantTypes::IODevice & v) {
return QAD::IODevice(PI2QString(v.prefix), PI2QPropertyStorage(v.get()), v.mode, v.options);
}
const QAD::File PI2QADFile(const PIVariantTypes::File & v) {
return QAD::File(PI2QString(v.file), PI2QString(v.filter), v.is_abs, v.is_save);
}
const QAD::Dir PI2QADDir(const PIVariantTypes::Dir & v) {
return QAD::Dir(PI2QString(v.dir), v.is_abs);
}
const PIVariantTypes::File QAD2PIFile(const QAD::File & v) {
return PIVariantTypes::File(Q2PIString(v.file), Q2PIString(v.filter), v.is_abs, v.is_save);
}
const PIVariantTypes::Dir QAD2PIDir(const QAD::Dir & v) {
return PIVariantTypes::Dir(Q2PIString(v.dir), v.is_abs);
}
#if QT_VERSION >= 0x050200
const QGeoCoordinate PI2QGeoPosition(const PIGeoPosition & v) {
PIGeoPosition p(v);
p.transformTo(PIGeoPosition::Cartesian);
p.setEllipsoidModel(PIEllipsoidModel::WGS84Ellipsoid());
p.transformTo(PIGeoPosition::Geodetic);
return QGeoCoordinate(p.latitudeGeodetic(), p.longitude(), p.height());
}
const PIGeoPosition Q2PIGeoPosition(const QGeoCoordinate & v) {
return PIGeoPosition(createVectorT3d(v.latitude(), v.longitude(), v.altitude()), PIGeoPosition::Geodetic);
}
#endif

169
libs/piqt/piqt.h Normal file
View File

@@ -0,0 +1,169 @@
/*
PIQt - PIP <-> Qt convertions
Ivan Pelipenko peri4ko@yandex.ru, Andrey Bychkov work.a.b@yandex.ru
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef PIQT_H
#define PIQT_H
#include "pimathmatrix.h"
#include "pipropertystorage.h"
#include "qad_types.h"
#include <QVector3D>
#include <QDateTime>
#include <QColor>
#if QT_VERSION >= 0x050200
# include "pigeoposition.h"
#endif
#include "piqt_export.h"
class QGeoCoordinate;
PIQT_EXPORT const QVariant PI2QVariant(const PIVariant & v);
PIQT_EXPORT const PIVariant Q2PIVariant(const QVariant & v);
//inline const QString PI2QString(const PIString & v) {return QString::fromLocal8Bit(v.data());}
inline const QString PI2QString(const PIString & v) {return QString::fromUtf8(v.dataUTF8());}
//inline const PIString Q2PIString(const QString & v) {return PIString(v.toLocal8Bit().data());}
inline const PIString Q2PIString(const QString & v) {return PIString::fromUTF8(v.toUtf8().data());}
inline const QStringList PI2QStringList(const PIStringList & v) {QStringList ret; piForeachC (PIString & s, v) ret << PI2QString(s); return ret;}
inline const PIStringList Q2PIStringList(const QStringList & v) {PIStringList ret; foreach (const QString & s, v) ret << Q2PIString(s); return ret;}
inline const QByteArray PI2QByteArray(const PIByteArray & v) {return QByteArray((const char *)(v.data()), v.size_s());}
inline const PIByteArray Q2PIByteArray(const QByteArray & v) {return PIByteArray(v.constData(), v.size());}
inline const QPointF PI2QVector2(const PIMathVectorT2d & v) {return QPointF(v[0], v[1]);}
inline const QVector3D PI2QVector3(const PIMathVectorT3d & v) {return QVector3D(v[0], v[1], v[2]);}
inline const PIMathVectorT2d Q2PIVector2(const QPointF & v) {return createVectorT2d(double(v.x()), double(v.y()));}
inline const PIMathVectorT3d Q2PIVector3(const QVector3D & v) {return createVectorT3d(double(v.x()), double(v.y()), double(v.z()));}
inline const QPointF PI2QPoint(const PIPointd & v) {return QPointF(v.x, v.y);}
inline const PIPointd Q2PIPoint(const QPointF & v) {return PIPointd(v.x(), v.y());}
inline const QRectF PI2QRect(const PIRectd & v) {return QRectF(v.x0, v.y0, v.width(), v.height());}
inline const PIRectd Q2PIRect(const QRectF & v) {return PIRectd(v.x(), v.y(), v.width(), v.height());}
inline const QAD::MathVector PI2QMathVector(const PIMathVectord & v) {
QVector<double> q = QVector<double>(v.size());
memcpy(q.data(), v.data(), q.size()*sizeof(double));
return QAD::MathVector(q);
}
inline const PIMathVectord Q2PIMathVector(const QAD::MathVector & v) {
PIMathVectord p = PIMathVectord(v.v.size());
memcpy(p.data(), v.v.data(), p.size()*sizeof(double));
return p;
}
inline const QAD::MathMatrix PI2QMathMatrix(const PIMathMatrixd & v) {
PIVector<PIVector<double> > p = v.toVectors();
QVector<QVector<double> > q = QVector<QVector<double> >(p.size());
for (int i = 0; i < q.size(); ++i) {
q[i].resize(p[i].size());
memcpy(q[i].data(), p[i].data(), q[i].size()*sizeof(double));
}
return QAD::MathMatrix(q);
}
inline const PIMathMatrixd Q2PIMathMatrix(const QAD::MathMatrix & v) {
PIVector<PIVector<double> > p = PIVector<PIVector<double> >(v.m.size());
for (int i = 0; i < v.m.size(); ++i) {
p[i].resize(v.m[i].size());
memcpy(p[i].data(), v.m[i].data(), p[i].size()*sizeof(double));
}
return PIMathMatrixd(p);
}
inline const QDate PI2QDate(const PIDate & v) {return QDate(v.year, v.month, v.day);}
inline const QTime PI2QTime(const PITime & v) {return QTime(v.hours, v.minutes, v.seconds, v.milliseconds);}
inline const QDateTime PI2QDateTime(const PIDateTime & v) {return QDateTime(PI2QDate(v.date()), PI2QTime(v.time()));}
inline const PIDate Q2PIDate(const QDate & v) {return PIDate(v.year(), v.month(), v.day());}
inline const PITime Q2PITime(const QTime & v) {return PITime(v.hour(), v.minute(), v.second(), v.msec());}
inline const PIDateTime Q2PIDateTime(const QDateTime & v) {return PIDateTime(Q2PIDate(v.date()), Q2PITime(v.time()));}
inline const QColor PI2QColor(const PIVariantTypes::Color & v) {return QColor::fromRgba(v.rgba);}
inline const PIVariantTypes::Color Q2PIColor(const QColor & v) {return PIVariantTypes::Color(v.rgba());}
inline PIPropertyStorage Q2PIPropertyStorage(const PropertyStorage & props) {
PIPropertyStorage ret;
foreach (const PropertyStorage::Property & p, props)
ret.addProperty(Q2PIString(p.name), Q2PIVariant(p.value), Q2PIString(p.comment), p.flags);
return ret;
}
inline PropertyStorage PI2QPropertyStorage(const PIPropertyStorage & props) {
PropertyStorage ret;
piForeachC (PIPropertyStorage::Property & p, props)
ret.addProperty(PI2QString(p.name), PI2QVariant(p.value), PI2QString(p.comment), p.flags);
return ret;
}
PIQT_EXPORT const QAD::Enum PI2QADEnum(const PIVariantTypes::Enum & el);
PIQT_EXPORT const QAD::File PI2QADFile(const PIVariantTypes::File & v);
PIQT_EXPORT const QAD::Dir PI2QADDir(const PIVariantTypes::Dir & v);
PIQT_EXPORT const QAD::IODevice PI2QADIODevice(const PIVariantTypes::IODevice & v);
PIQT_EXPORT const PIVariantTypes::Enum QAD2PIEnum(const QAD::Enum & el);
PIQT_EXPORT const PIVariantTypes::File QAD2PIFile(const QAD::File & v);
PIQT_EXPORT const PIVariantTypes::Dir QAD2PIDir(const QAD::Dir & v);
PIQT_EXPORT const PIVariantTypes::IODevice QAD2PIIODevice(const QAD::IODevice & v);
//inline const PIVariant QString2PIVariant(const QString & v) {return PIVariant::readFromString(QString2PIString(v));}
#if QT_VERSION >= 0x050200
PIQT_EXPORT const QGeoCoordinate PI2QGeoPosition(const PIGeoPosition & v);
PIQT_EXPORT const PIGeoPosition Q2PIGeoPosition(const QGeoCoordinate & v);
#endif
template <typename From>
class __PIQtConverter {
public:
__PIQtConverter(const From & v): val(v) {}
template <typename To> operator To() {return To();}
From val;
};
template<typename From> inline __PIQtConverter<From> __PIQtConvert(const From & f) {return __PIQtConverter<From>(f);}
#define _PIQt_CONVERT(ft, tt, ftc, tfc) \
template<> template<> inline __PIQtConverter<ft>::operator tt() {return ftc(val);} \
template<> template<> inline __PIQtConverter<tt>::operator ft() {return tfc(val);}
#define _PIQt_CONVERT_S(t) _PIQt_CONVERT(PI##t, Q##t, PI2Q##t, Q2PI##t)
_PIQt_CONVERT_S(String)
_PIQt_CONVERT_S(ByteArray)
_PIQt_CONVERT_S(Time)
_PIQt_CONVERT_S(Date)
_PIQt_CONVERT_S(DateTime)
_PIQt_CONVERT(PIMathVectorT2d, QPointF, PI2QVector2, Q2PIVector2)
_PIQt_CONVERT(PIMathVectorT3d, QVector3D, PI2QVector3, Q2PIVector3)
#define piqt __PIQtConvert
#define qtpi __PIQtConvert
#endif // PIQT_H

30
libs/piqt/qpiconnection.cpp Normal file
View File

@@ -0,0 +1,30 @@
#include "qpiconnection.h"
QPIConnection::QPIConnection(const QString & name): QObject(), PIConnection(Q2PIString(name)) {
setObjectName(name);
CONNECTU(this, dataReceivedEvent, this, piDataRec);
CONNECTU(this, packetReceivedEvent, this, piPacketRec);
}
bool QPIConnection::loadFromCMFile(const QString & file) {
QPIConfig f(file, QIODevice::ReadOnly);
if (!f.isOpen()) return false;
PIString cs = Q2PIString(QString::fromLatin1(f.getValue("config").toByteArray()));
configureFromString(&cs, Q2PIString(f.getValue("name").toString()));
return true;
}
void QPIConnection::piDataRec(const PIString & from, const PIByteArray & data) {
//piCout << from << PICoutManipulators::Hex << data;
QMetaObject::invokeMethod(this, "qDataReceivedEvent", Qt::QueuedConnection,
Q_ARG(QString, PI2QString(from)), Q_ARG(QByteArray, PI2QByteArray(data)));
}
void QPIConnection::piPacketRec(const PIString & from, const PIByteArray & data) {
QMetaObject::invokeMethod(this, "qPacketReceivedEvent", Qt::QueuedConnection,
Q_ARG(QString, PI2QString(from)), Q_ARG(QByteArray, PI2QByteArray(data)));
}

52
libs/piqt/qpiconnection.h Normal file
View File

@@ -0,0 +1,52 @@
/*
PIQt Utils - Qt utilites for PIP
Ivan Pelipenko peri4ko@yandex.ru, Andrey Bychkov work.a.b@yandex.ru
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef QPICONNECTION_H
#define QPICONNECTION_H
#include <QObject>
#include <QMetaObject>
#include "piconnection.h"
#include "qpiconfig.h"
#include "piqt.h"
#include "piqt_export.h"
class PIQT_EXPORT QPIConnection: public QObject, public PIConnection {
Q_OBJECT
PIOBJECT_SUBCLASS(QPIConnection, PIConnection)
public:
QPIConnection(const QString & name = QString());
bool loadFromCMFile(const QString & file);
protected:
void propertyChanged(const PIString & ) {setObjectName(PI2QString(name()));}
EVENT_HANDLER2(void, piDataRec, const PIString &, from, const PIByteArray &, data);
EVENT_HANDLER2(void, piPacketRec, const PIString &, from, const PIByteArray &, data);
public slots:
signals:
void qDataReceivedEvent(QString from, QByteArray data);
void qPacketReceivedEvent(QString from, QByteArray data);
};
#endif // QPICONNECTION_H