flightsimulatorplatfrom/pilotclient
1
0
Fork 0
mirror of https://github.com/swift-project/pilotclient.git synced 2026-03-30 11:55:35 +08:00
Code Issues Packages Projects Releases Wiki Activity

refs #247 Removed code which is no longer used.

Browse Source
This commit is contained in:
Mathew Sutcliffe
2014-12-06 16:33:42 +00:00
parent 3a9ff3112f
commit 599068e25b
6 changed files with 0 additions and 223 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
src/blackcore/context_settings.h
View File

@@ -17,7 +17,6 @@
#include "blackmisc/variant.h"
#include "blackcore/settingsallclasses.h"
#include <QObject>
#include <QVariant>
//! \addtogroup dbus
//! @{

2
src/blackcore/context_settings_proxy.h
View File

@@ -14,8 +14,6 @@
#include "blackmisc/setnetwork.h"
#include "blackmisc/hwkeyboardkeylist.h"
#include <QVariant>
namespace BlackCore
{

145
src/blackmisc/blackmiscfreefunctions.cpp
View File

@@ -137,151 +137,6 @@ void BlackMisc::initResources()
initBlackMiscResources();
}
/*
* Stupid extension bo be able to compare 2 QVariants
*/
bool BlackMisc::equalQVariants(const QVariant &v1, const QVariant &v2)
{
// Compares this QVariant with v and returns true if they are equal; otherwise returns false.
// In the case of custom types, their equalness operators are not called. Instead the values' addresses are compared.
if (v1 == v2) return true;
// shortcuts
if (!v1.isValid() || !v2.isValid()) return false;
if (v1.type() != v2.type()) return false;
if (v1.userType() != v2.userType()) return false;
// I have same types now
int c = compareQVariants(v1, v2);
return c == 0;
}
/*
* Compare values
*/
int BlackMisc::compareQVariants(const QVariant &v1, const QVariant &v2)
{
// Compares this QVariant with v and returns true if they are equal; otherwise returns false.
// In the case of custom types, their equalness operators are not called. Instead the values' addresses are compared.
if (v1 == v2) return 0;
if (!v1.isValid() || !v2.isValid()) qFatal("Invalid variants");
if (v1.type() != v2.type()) qFatal("Mismatching types");
if (v1.userType() != v2.userType()) qFatal("Mismatching user types");
auto v1Type = static_cast<QMetaType::Type>(v1.type());
switch (v1Type)
{
case QMetaType::QString:
case QMetaType::QChar:
{
QString s1 = v1.value<QString>();
QString s2 = v2.value<QString>();
return s1.compare(s2);
}
case QMetaType::QDateTime:
{
QDateTime dt1 = v1.value<QDateTime>();
QDateTime dt2 = v2.value<QDateTime>();
if (dt1 == dt2) return 0;
return dt1 < dt2 ? -1 : 1;
}
case QMetaType::QDate:
{
QDate d1 = v1.value<QDate>();
QDate d2 = v2.value<QDate>();
if (d1 == d2) return 0;
return d1 < d2 ? -1 : 1;
}
case QMetaType::QTime:
{
QTime t1 = v1.value<QTime>();
QTime t2 = v2.value<QTime>();
if (t1 == t2) return 0;
return t1 < t2 ? -1 : 1;
}
case QMetaType::QPixmap:
{
QPixmap p1 = v1.value<QPixmap>();
QPixmap p2 = v2.value<QPixmap>();
if (p1.width() == p2.width()) return 0;
return p1.width() < p2.width() ? -1 : 1;
}
default:
break;
}
// CValueObject
if (v1Type == QMetaType::User)
{
const CValueObject *cs1 = CValueObject::fromQVariant(v1);
const CValueObject *cs2 = CValueObject::fromQVariant(v2);
if (cs1 && cs2)
{
return compare(*cs1, *cs2);
}
}
// integer types, handling not as double for rounding issues
if (v1Type == QMetaType::Int)
{
int i1 = v1.value<int>();
int i2 = v2.value<int>();
if (i1 == i2) return 0;
return i1 < i2 ? -1 : 1;
}
else if (v1Type == QMetaType::UInt)
{
uint i1 = v1.value<uint>();
uint i2 = v2.value<uint>();
if (i1 == i2) return 0;
return i1 < i2 ? -1 : 1;
}
else if (v1Type == QMetaType::LongLong)
{
long long i1 = v1.value<long long>();
long long i2 = v2.value<long long>();
if (i1 == i2) return 0;
return i1 < i2 ? -1 : 1;
}
else if (v1Type == QMetaType::ULongLong)
{
unsigned long long i1 = v1.value<unsigned long long>();
unsigned long long i2 = v2.value<unsigned long long>();
if (i1 == i2) return 0;
return i1 < i2 ? -1 : 1;
}
// all kind of numeric values
if (v1.canConvert<double>())
{
double d1 = v1.value<double>();
double d2 = v2.value<double>();
if (d1 == d2) return 0;
return d1 < d2 ? -1 : 1;
}
qFatal("Unknown type for compare");
return -1;
}
/*
* To string
*/
QString BlackMisc::qVariantToString(const QVariant &qv, bool i18n)
{
if (qv.type() != QVariant::UserType) return qv.toString();
const CValueObject *s = CValueObject::fromQVariant(qv);
if (s)
{
return s->toQString(i18n);
}
else
{
return "unknown";
}
}
/*
* Add hash values
*/

14
src/blackmisc/blackmiscfreefunctions.h
View File

@@ -101,20 +101,6 @@ namespace BlackMisc
//! Init resources
void initResources();
//! Compare 2 QVariants
bool equalQVariants(const QVariant &v1, const QVariant &v2);
//! Compare QVariants
int compareQVariants(const QVariant &v1, const QVariant &v2);
/*!
* \brief QVariant to QString, allows to stringify CValueObject
* \param qv QVariant containing any CValueObject
* \param i18n
* \return
*/
QString qVariantToString(const QVariant &qv, bool i18n = false);
/*!
* Checked version from QVariant
*/

25
src/blackmisc/valueobject.cpp
View File

@@ -109,23 +109,6 @@ namespace BlackMisc
return this->propertyByIndex(index) == compareValue;
}
/*
* Return backing streamable object (if any)
*/
const CValueObject *CValueObject::fromQVariant(const QVariant &variant)
{
if (!variant.isValid()) return nullptr;
auto t = static_cast<QMetaType::Type>(variant.type());
uint ut = variant.userType();
if (t != QMetaType::User) return nullptr; // not a user type
if (ut <= static_cast<uint>(QMetaType::User)) return nullptr; // complex Qt type
if (variant.canConvert<QDBusArgument>()) return nullptr; // not unstreamed yet
// this cast cannot be dynamic, so the above conditions are crucical
const CValueObject *vo = static_cast<const CValueObject *>(variant.constData());
return vo;
}
/*
* Compare
*/
@@ -170,14 +153,6 @@ namespace BlackMisc
return changed;
}
/*
* equals QVariant?
*/
bool CValueObject::equalsQVariant(const QVariant &qVariant) const
{
return BlackMisc::equalQVariants(this->toQVariant(), qVariant);
}
/*
* Icon
*/

36
src/blackmisc/valueobject.h
View File

@@ -178,9 +178,6 @@ namespace BlackMisc
//! Method to return CVariant
CVariant toCVariant() const;
//! Equals another CValueObject in QVariant?
virtual bool equalsQVariant(const QVariant &qVariant) const;
//! Set from QVariant
virtual void convertFromQVariant(const QVariant &variant) = 0;
@@ -212,9 +209,6 @@ namespace BlackMisc
//! Is given variant equal to value of property index?
virtual bool equalsPropertyByIndex(const CVariant &compareValue, const CPropertyIndex &index) const;
//! The stored object as CValueObject
static const CValueObject *fromQVariant(const QVariant &variant);
protected:
template <typename T>
friend struct Private::CValueObjectMetaInfo;
@@ -506,36 +500,6 @@ namespace BlackMisc
return json;
}
//! Allow comparison with QVariant, e.g. QVariant == CFrequency ?
template <class T> typename std::enable_if<std::is_base_of<CValueObject, T>::value, bool>::type
operator==(const QVariant &variant, const T &valueObject)
{
if (!variant.canConvert<T>()) return false;
T vuc = variant.value<T>();
return vuc == valueObject;
}
//! Allow comparison with QVariant, e.g. QVariant != CFrequency ?
template <class T> typename std::enable_if<std::is_base_of<CValueObject, T>::value, bool>::type
operator!=(const QVariant &variant, const T &valueObject)
{
return !(variant == valueObject);
}
//! Allow comparison with QVariant, e.g. QVariant == CFrequency ?
template <class T> typename std::enable_if<std::is_base_of<CValueObject, T>::value, bool>::type
operator==(const T &valueObject, const QVariant &variant)
{
return variant == valueObject;
}
//! Allow comparison with QVariant, e.g. QVariant != CFrequency ?
template <class T> typename std::enable_if<std::is_base_of<CValueObject, T>::value, bool>::type
operator!=(const T &valueObject, const QVariant &variant)
{
return variant != valueObject;
}
//! qHash overload, needed for storing CValueObject in a QSet.
inline uint qHash(const BlackMisc::CValueObject &value, uint seed = 0)
{