basetoqt.h

Go to the documentation of this file.

#pragma once
#include "avect.h"
#include "base.h"
#include "property.h"
#include "basei.h"
#ifdef _WIN32
#include <codeanalysis\warnings.h>
#endif
 
PUSHWARNING
VSWARNING(ALL_CODE_ANALYSIS_WARNINGS)
VSWARNING(4251)
VSWARNING(4244)
VSWARNING(4127)
CLANGWARNING("-Wlanguage-extension-token")
CLANGWARNING("-Wmicrosoft-enum-value")
//INTELLLVMWARNING("-Wmicrosoft-unqualified-friend")
INTELWARNING(1744) // DLL Interface
INTELWARNING(3280) // Declaration hides member
namespace Qt {
 class weak_ordering;
 class strong_ordering;
}
#include <QtCore>
POPWARNING
 
#undef rad1
#undef rad2
#undef small
#undef near
#undef far
#undef grp1
#undef grp2
 
#if QT_VERSION > 0x060000
# define QT6
#elif QT_VERSION > 0x050000
# define QT5
#endif
 
#ifndef DOXYGEN
// The following are commented since they should not be used with Qt anyway
//Q_DECLARE_METATYPE(quint64);
Q_DECLARE_METATYPE(string)
//Q_DECLARE_METATYPE(String);
Q_DECLARE_METATYPE(Variant)
Q_DECLARE_METATYPE(IVect2)
Q_DECLARE_METATYPE(FVect2)
Q_DECLARE_METATYPE(DVect2)
Q_DECLARE_METATYPE(UVect2)
Q_DECLARE_METATYPE(DAVect2)
Q_DECLARE_METATYPE(FAVect2)
Q_DECLARE_METATYPE(IAVect2)
Q_DECLARE_METATYPE(UAVect2)
Q_DECLARE_METATYPE(IVect3)
Q_DECLARE_METATYPE(FVect3)
Q_DECLARE_METATYPE(DVect3)
Q_DECLARE_METATYPE(UVect3)
Q_DECLARE_METATYPE(DAVect3)
Q_DECLARE_METATYPE(FAVect3)
Q_DECLARE_METATYPE(IAVect3)
Q_DECLARE_METATYPE(UAVect3)
Q_DECLARE_METATYPE(Orientation2)
Q_DECLARE_METATYPE(Orientation3)
Q_DECLARE_METATYPE(Axes2D)
Q_DECLARE_METATYPE(Axes3D)
Q_DECLARE_METATYPE(Quat2)
Q_DECLARE_METATYPE(Quat3)
Q_DECLARE_METATYPE(SymTensor)
Q_DECLARE_METATYPE(itasca::Mat)
#endif
//#ifndef __GNUC__
//#pragma warning(pop)
//#endif
 
// Ensure always utf-8
class ItascaTextStream : public QTextStream {
public:
 BASE_EXPORT ItascaTextStream() : QTextStream() {
 setEncoding(QStringConverter::Encoding::Utf8);
 }
 
 BASE_EXPORT ItascaTextStream(const QByteArray &array, QIODevice::OpenMode openMode = QIODevice::ReadOnly) : QTextStream(array,openMode) {
 setEncoding(QStringConverter::Encoding::Utf8);
 }
 
 BASE_EXPORT ItascaTextStream(QByteArray *array, QIODevice::OpenMode openMode = QIODevice::ReadWrite) : QTextStream(array,openMode) {
 setEncoding(QStringConverter::Encoding::Utf8);
 }
 
 BASE_EXPORT ItascaTextStream(QString *string, QIODevice::OpenMode openMode = QIODevice::ReadWrite) : QTextStream(string,openMode) {
 setEncoding(QStringConverter::Encoding::Utf8);
 }
 
 BASE_EXPORT ItascaTextStream(FILE *fileHandle, QIODevice::OpenMode openMode = QIODevice::ReadWrite) : QTextStream(fileHandle,openMode) {
 setEncoding(QStringConverter::Encoding::Utf8);
 }
 
 BASE_EXPORT ItascaTextStream(QIODevice *device) : QTextStream(device) {
 setEncoding(QStringConverter::Encoding::Utf8);
 }
};
 
BASE_EXPORT void initializeQtToBase();
 
// QDataStream functions
//
// NOTE: This is left for compatibility, but will be removed in the future.
// you should avoid using QDataStream even in Qt code!
//
template <class T> inline QDataStream &operator<<(QDataStream &ds,const Vector2<T> &v) {
 ds << v.x() << v.y();
 return ds;
}
template <class T> inline QDataStream &operator>>(QDataStream &ds,Vector2<T> &v) {
 ds >> v.rx() >> v.ry();
 return ds;
}
template <class T> inline QDataStream &operator<<(QDataStream &ds,const Vector3<T> &v) {
 ds << v.x() << v.y() << v.z();
 return ds;
}
template <class T> inline QDataStream &operator>>(QDataStream &ds,Vector3<T> &v) {
 ds >> v.rx() >> v.ry() >> v.rz();
 return ds;
}
template <class T> inline QDataStream &operator<<(QDataStream &ds,const AVector2<T> &av) {
 ds << av.z();
 return ds;
}
template <class T> inline QDataStream &operator>>(QDataStream &ds,AVector2<T> &av) {
 ds >> av.rz();
 return ds;
}
 
template <class T> inline QDataStream &operator<<(QDataStream &ds,const AVector3<T> &av) {
 ds << av.x() << av.y() << av.z();
 return ds;
}
template <class T> inline QDataStream &operator>>(QDataStream &ds,AVector3<T> &av) {
 ds >> av.rx() >> av.ry() >> av.rz();
 return ds;
}
 
// Streaming Extent2 and Extent3
template <class T> inline QDataStream &operator<<(QDataStream &ds,const Extent2<T> &v) {
 ds << v.x1() << v.x2() << v.y1() << v.y2();
 return ds;
}
template <class T> inline QDataStream &operator>>(QDataStream &ds,Extent2<T> &v) {
 ds >> v.rx1() >> v.rx2() >> v.ry1() >> v.ry2();
 return ds;
}
template <class T> inline QDataStream &operator<<(QDataStream &ds,const Extent3<T> &v) {
 ds << v.x1() << v.x2() << v.y1() << v.y2() << v.z1() << v.z2();
 return ds;
}
template <class T> inline QDataStream &operator>>(QDataStream &ds,Extent3<T> &v) {
 ds >> v.rx1() >> v.rx2() >> v.ry1() >> v.ry2() >> v.rz1() >> v.rz2();
 return ds;
}
 
// Data Streaming Orientation, Axes, Variant, string, and SymTensor classes.
BASE_EXPORT QDataStream &operator<<(QDataStream &ds,const Orientation2 &o);
BASE_EXPORT QDataStream &operator>>(QDataStream &ds,Orientation2 &o); 
BASE_EXPORT QDataStream &operator<<(QDataStream &ds,const Orientation3 &o); 
BASE_EXPORT QDataStream &operator>>(QDataStream &ds,Orientation3 &o); 
BASE_EXPORT QDataStream &operator<<(QDataStream &ds,const Axes2D &v); 
BASE_EXPORT QDataStream &operator>>(QDataStream &ds,Axes2D &v); 
BASE_EXPORT QDataStream &operator<<(QDataStream &ds,const Axes3D &v); 
BASE_EXPORT QDataStream &operator>>(QDataStream &ds,Axes3D &v); 
BASE_EXPORT QDataStream &operator<<(QDataStream &ds,const CAxes2D &v); 
BASE_EXPORT QDataStream &operator>>(QDataStream &ds,CAxes2D &v); 
BASE_EXPORT QDataStream &operator<<(QDataStream &ds,const CAxes3D &v); 
BASE_EXPORT QDataStream &operator>>(QDataStream &ds,CAxes3D &v); 
BASE_EXPORT QDataStream &operator<<(QDataStream &ds,const Variant &v); 
BASE_EXPORT QDataStream &operator>>(QDataStream &ds,Variant &v); 
BASE_EXPORT QDataStream &operator<<(QDataStream &ds,const std::wstring &v); 
BASE_EXPORT QDataStream &operator>>(QDataStream &ds,std::wstring &v); 
BASE_EXPORT QDataStream &operator<<(QDataStream &ds,const string &v); 
BASE_EXPORT QDataStream &operator>>(QDataStream &ds,string &v); 
BASE_EXPORT QDataStream &operator<<(QDataStream &ds,const SymTensor &s); 
BASE_EXPORT QDataStream &operator>>(QDataStream &ds,SymTensor &v); 
BASE_EXPORT QDataStream &operator<<(QDataStream &ds,const Quat2 &o); 
BASE_EXPORT QDataStream &operator>>(QDataStream &ds,Quat2 &o); 
BASE_EXPORT QDataStream &operator<<(QDataStream &ds,const Quat3 &o); 
BASE_EXPORT QDataStream &operator>>(QDataStream &ds,Quat3 &o); 
BASE_EXPORT QDataStream &operator<<(QDataStream &ds,const itasca::Mat &o); 
BASE_EXPORT QDataStream &operator>>(QDataStream &ds,itasca::Mat &o); 
 
// QTextStream functions
template <class T> inline QTextStream &operator<<(QTextStream &ds,const Vector2<T> &v) {
 int w = ds.fieldWidth();
 w = std::max(0,w-3);
 w /= 2;
 ds << qSetFieldWidth(0) << "(" << qSetFieldWidth(w) << v.x();
 ds << qSetFieldWidth(0) << "," << qSetFieldWidth(w) << v.y();
 ds << qSetFieldWidth(0) << ")";
 return ds;
}
template <class T> inline QTextStream &operator<<(QTextStream &ds,const Vector3<T> &v) {
 int w = ds.fieldWidth();
 w = std::max(0,w-4);
 w /= 3;
 ds << qSetFieldWidth(0) << "(" << qSetFieldWidth(w) << v.x();
 ds << qSetFieldWidth(0) << "," << qSetFieldWidth(w) << v.y();
 ds << qSetFieldWidth(0) << "," << qSetFieldWidth(w) << v.z();
 ds << qSetFieldWidth(0) << ")";
 return ds;
}
template <class T> inline QTextStream &operator<<(QTextStream &ds,const AVector2<T> &v) {
 ds << v.z();
 return ds;
}
 
// Conversion to Qt Core 2D vector types
template <class T> inline QPoint toQPoint(const Vector2<T> &v) {
 QPoint ret(to<int>(v.x()),to<int>(v.y()));
 return ret;
}
template <class T> inline QPointF toQPointF(const Vector2<T> &v) {
 QPointF ret(to<qreal>(v.x()),to<qreal>(v.y()));
 return ret;
}
inline DVect2 toDVect2(const QPoint &p) {
 DVect2 dv2(to<double>(p.x()),to<double>(p.y()));
 return dv2;
}
inline DVect2 toDVect2(const QSize &p) {
 DVect2 dv2(to<double>(p.width()),to<double>(p.height()));
 return dv2;
}
inline FVect2 toFVect2(const QPoint &p) {
 FVect2 fv2(to<float>(p.x()),to<float>(p.y()));
 return fv2;
}
inline IVect2 toIVect2(const QPoint &p) {
 IVect2 iv2(to<int32>(p.x()),to<int32>(p.y()));
 return iv2;
}
 
inline I64Vect2 toI64Vect2(const QPoint &p) {
 I64Vect2 iv2(to<int64>(p.x()),to<int64>(p.y()));
 return iv2;
}
 
inline UVect2 toUVect2(const QPoint &p) {
 UVect2 uv2(to<uint32>(p.x()),to<uint32>(p.y()));
 return uv2;
}
inline DVect2 toDVect2(const QPointF &p) {
 DVect2 dv2(to<double>(p.x()),to<double>(p.y()));
 return dv2;
}
inline FVect2 toFVect2(const QPointF &p) {
 FVect2 fv2(to<float>(p.x()),to<float>(p.y()));
 return fv2;
}
inline IVect2 toIVect2(const QPointF &p) {
 IVect2 iv2(to<int32>(p.x()),to<int32>(p.y()));
 return iv2;
}
inline UVect2 toUVect2(const QPointF &p) {
 UVect2 uv2(to<uint32>(p.x()),to<uint32>(p.y()));
 return uv2;
}
 
inline bool checkQVariantTypes(const QVariant &v1, const QVariant &v2)
{
 int type1 = static_cast<int>(v1.typeId());
 int type2 = static_cast<int>(v2.typeId());
#ifdef QT5
 if (type1 == QMetaType::User)
 {
 type1 = v1.userType();
 if (type2 == QMetaType::User)
 type2 = v2.userType();
 else
 return false;
 }
#endif
 return type1 == type2;
}
 
// Converts from QVariant to Variant and vice versa.
template <typename T>
QVariant toQVariant(const T &t) { QVariant v; v.setValue(t); return v; }
template <> BASE_EXPORT QVariant toQVariant<Variant>(const Variant &v);
template <> BASE_EXPORT QVariant toQVariant<base::Property>(const base::Property &prop);
 
BASE_EXPORT Variant toVariant(const QVariant &v);
// Convert a QVariant to a Property
BASE_EXPORT base::Property toProperty(const QVariant &v);
 
BASE_EXPORT bool isDirectoryProtected(const QDir &dir,const QString &registryString);
 
BASE_EXPORT QString getInstallDirectory(const QString &registryString);
 
BASE_EXPORT QString convertFilePath(const QString &filePath,const QDir &previousDir,const QDir &newDir);
 
BASE_EXPORT bool setCurrentDirectory(const IString &dir);
 
BASE_EXPORT QString getCurrentDirectory();
 
BASE_EXPORT QDir getCurrentDirectoryObject();
 
// This allows you to send QVariant to a fmt::format
template <>
struct fmt::formatter<QVariant> : public fmt::formatter<string> {
 template <typename ParseContext>
 constexpr auto parse(ParseContext &ctx) {
 return fmt::formatter<string>::parse(ctx);
 }
 
 template <typename FormatContext> auto format(QVariant const& val, FormatContext& ctx) {
 string out;
 auto type = val.typeId();
 if (type == QMetaType::Bool)
 out = base::ts(val.toBool());
 else if (type == QMetaType::Int)
 out = base::ts(val.toInt());
 else if (type == QMetaType::UInt)
 out = base::ts(val.toUInt());
 else if (type == QMetaType::LongLong)
 out = base::ts(val.toLongLong());
 else if (type == QMetaType::ULongLong)
 out = base::ts(val.toULongLong());
 else if (type == QMetaType::Double)
 out = base::ts(val.toDouble());
 else if (type == QMetaType::QString)
 out = base::ts(val.toString());
 else if (type == QMetaType::QVariantList) {
 out = "(";
 auto list = val.toList();
 for (int i=0;i<list.size();++i) {
 if (i) out += ",";
 out += base::ts(list[i].toDouble());
 }
 out += ")";
 } else if (type == qMetaTypeId<IVect2>()) 
 out = base::ts(val.value<IVect2 >());
 else if (type == qMetaTypeId<DVect2>()) 
 out = base::ts(val.value<DVect2 >());
 else if (type == qMetaTypeId<IVect3>()) 
 out = base::ts(val.value<IVect3 >());
 else if (type == qMetaTypeId<DVect3>()) 
 out = base::ts(val.value<DVect3 >());
 else if (type == qMetaTypeId<DAVect2>()) 
 out = base::ts(val.value<DAVect2>());
 else if (type == qMetaTypeId<DAVect3>()) 
 out = base::ts(val.value<DAVect3>());
 else
 throw Exception("Unable to format QVariant type {}.", val.typeName());
 return fmt::formatter<string>::format(out, ctx);
 }
};
// EOF