984d926 · unity8 · git.iko.soy

git.iko.soy/unity8

on xenial help sign in

Remove the variant conversions methods as they were moved to dee-qt.

984d926Michal Hruby13 years ago

debian/control+1−1

compare with xenial

unifiedsplit

@@ -4,7 +4,7 @@ Priority: optional

4Maintainer: Ubuntu Developers <ubuntu-devel-discuss@lists.ubuntu.com>

5Build-Depends: cmake,

6 debhelper (>= 9),

7− libdee-qt5-dev (>= 3.0),

7+ libdee-qt5-dev (>= 3.2),

8 libgl1-mesa-dev[!armhf] | libgl-dev[!armhf],

9 libgl1-mesa-dri,

10 libgles2-mesa-dev[armhf],

plugins/Unity/CMakeLists.txt+1−1

@@ -5,7 +5,7 @@ add_subdirectory(Indicators)

6# Dependencies

7include(FindPkgConfig)

8−pkg_check_modules(QTDEE REQUIRED libdee-qt5)

8+pkg_check_modules(QTDEE REQUIRED libdee-qt5>=3.2)

9pkg_check_modules(UNITYCORE REQUIRED unity-core-6.0)

11include_directories(

plugins/Unity/previewinfohint.cpp+2−2

@@ -17,9 +17,9 @@

17 * along with this program. If not, see <http://www.gnu.org/licenses/>.

18 */

20+#include <deelistmodel.h>

20// local

21// local

21#include "previewinfohint.h"

22#include "previewinfohint.h"

22−#include "variantutils.h"

24PreviewInfoHint::PreviewInfoHint(QObject *parent):

25 QObject(parent),

@@ -61,7 +61,7 @@ QString PreviewInfoHint::iconHint() const

61QVariant PreviewInfoHint::value() const

62{

63 if (m_unityInfoHint) {

64− return QVariantFromGVariant(m_unityInfoHint->value);

64+ return DeeListModel::VariantForData(m_unityInfoHint->value);

65 }

66 return QVariant();

67}

plugins/Unity/variantutils.cpp+2−118

@@ -17,131 +17,15 @@

17 * along with this program. If not, see <http://www.gnu.org/licenses/>.

18 */

20+#include <deelistmodel.h>

20#include "variantutils.h"

21#include "variantutils.h"

22−/* Returns floating ref */

23−GVariant* GVariantFromQVariant(const QVariant &var)

24−{

25− GVariant *gv = nullptr;

26−

27− switch (var.type()) {

28− case QVariant::String:

29− gv = g_variant_new_string(var.toString().toUtf8());

30− break;

31− case QVariant::UInt:

32− gv = g_variant_new_uint32(var.toUInt());

33− break;

34− case QVariant::Int:

35− gv = g_variant_new_int32(var.toInt());

36− break;

37− case QVariant::LongLong:

38− gv = g_variant_new_int64(var.toLongLong());

39− break;

40− case QVariant::ULongLong:

41− gv = g_variant_new_uint64(var.toULongLong());

42− break;

43− case QVariant::Double:

44− gv = g_variant_new_double(var.toDouble());

45− break;

46− case QVariant::Bool:

47− gv = g_variant_new_boolean(var.toBool());

48− break;

49− case QVariant::Hash: {

50− const auto hash = var.toHash();

51− GVariant **children = new GVariant*[hash.size()];

52− int cnt = 0;

53− QHash<QString, QVariant>::const_iterator it = hash.constBegin();

54− while (it != hash.constEnd()) {

55− GVariant *key = g_variant_new_string(it.key().toUtf8());

56− children[cnt++] = g_variant_new_dict_entry(key, g_variant_new_variant(GVariantFromQVariant(it.value())));

57− ++it;

58− }

59− gv = g_variant_new_array(G_VARIANT_TYPE("{sv}"), children, hash.size());

60− delete [] children;

61− break;

62− }

63− default:

64− break;

65− }

66− return gv;

67−}

68−

69−// implementation of this conversion taken from libdee-qt private utility function.

70−QVariant QVariantFromGVariant(GVariant *value)

71−{

72− /* We need to special-case a{sv} here as G_VARIANT_CLASS_ARRAY handles simple arrays;

73− we need to create QVariantHash, not a list */

74− if (g_variant_is_of_type(value, G_VARIANT_TYPE_VARDICT)) {

75− const gsize nChildren = g_variant_n_children(value);

76− QVariantHash hash;

77− for (gsize i = 0; i < nChildren; ++i)

78− {

79− GVariant* dict_entry = g_variant_get_child_value(value, i);

80−

81− gchar* dict_key;

82− GVariant *dict_var;

83− g_variant_get(dict_entry, "{&sv}", &dict_key, &dict_var);

84− hash.insert(QString::fromUtf8(dict_key), QVariantFromGVariant(dict_var));

85− g_variant_unref(dict_var);

86− g_variant_unref(dict_entry);

87− }

88− return hash;

89− }

90−

91− switch (g_variant_classify(value)) {

92− case G_VARIANT_CLASS_BOOLEAN:

93− return QVariant((bool) g_variant_get_boolean(value));

94− case G_VARIANT_CLASS_BYTE:

95− return QVariant((uchar) g_variant_get_byte(value));

96− case G_VARIANT_CLASS_INT16:

97− return QVariant((qint16) g_variant_get_int16(value));

98− case G_VARIANT_CLASS_UINT16:

99− return QVariant((quint16) g_variant_get_uint16(value));

100− case G_VARIANT_CLASS_INT32:

101− return QVariant((qint32) g_variant_get_int32(value));

102− case G_VARIANT_CLASS_UINT32:

103− return QVariant((quint32) g_variant_get_uint32(value));

104− case G_VARIANT_CLASS_INT64:

105− return QVariant((qint64) g_variant_get_int64(value));

106− case G_VARIANT_CLASS_UINT64:

107− return QVariant((quint64) g_variant_get_uint64(value));

108− case G_VARIANT_CLASS_DOUBLE:

109− return QVariant(g_variant_get_double(value));

110− case G_VARIANT_CLASS_STRING:

111− return QVariant(QString::fromUtf8(g_variant_get_string(value, NULL)));

112− case G_VARIANT_CLASS_ARRAY:

113− case G_VARIANT_CLASS_TUPLE:

114− {

115− const gsize nChildren = g_variant_n_children(value);

116− QList<QVariant> array;

117− for (gsize i = 0; i < nChildren; ++i)

118− {

119− GVariant* gvariant = g_variant_get_child_value(value, i);

120− array << QVariantFromGVariant(gvariant);

121− g_variant_unref(gvariant);

122− }

123− return array;

124− }

125− default:

126− /* Fallback on an empty QVariant.

127− FIXME: Missing conversion of following GVariant types:

128− - G_VARIANT_CLASS_HANDLE

129− - G_VARIANT_CLASS_OBJECT_PATH

130− - G_VARIANT_CLASS_SIGNATURE

131− - G_VARIANT_CLASS_VARIANT

132− - G_VARIANT_CLASS_MAYBE

133− - G_VARIANT_CLASS_DICT_ENTRY

134− */

135− return QVariant();

136− }

137−}

138−

139unity::glib::HintsMap convertToHintsMap(const QHash<QString, QVariant> &val)

23unity::glib::HintsMap convertToHintsMap(const QHash<QString, QVariant> &val)

140{

24{

141 unity::glib::HintsMap hintsMap;

25 unity::glib::HintsMap hintsMap;

142 QHash<QString, QVariant>::const_iterator it = val.constBegin();

26 QHash<QString, QVariant>::const_iterator it = val.constBegin();

143 while (it != val.constEnd()) {

27 while (it != val.constEnd()) {

144− hintsMap[it.key().toStdString()] = GVariantFromQVariant(it.value());

28+ hintsMap[it.key().toStdString()] = DeeListModel::DataFromVariant(it.value());

145 ++it;

29 ++it;

146 }

30 }

147 return hintsMap;

31 return hintsMap;

plugins/Unity/variantutils.h−2

@@ -26,8 +26,6 @@

26// libunity-core

27#include <UnityCore/Variant.h>

29−GVariant* GVariantFromQVariant(const QVariant &value);

30−QVariant QVariantFromGVariant(GVariant *value);

31unity::glib::HintsMap convertToHintsMap(const QHash<QString, QVariant> &val);

29unity::glib::HintsMap convertToHintsMap(const QHash<QString, QVariant> &val);

32unity::glib::HintsMap convertToHintsMap(const QVariant &var);

30unity::glib::HintsMap convertToHintsMap(const QVariant &var);