@@ -1,5 +1,5 @@
11/*
2− * Copyright (C) 2015 Canonical Ltd.
2+ * Copyright (C) 2016 Canonical Ltd.
33 *
44 * This program is free software: you can redistribute it and/or modify it
55 * under the terms of the GNU General Public License version 3, as published
@@ -18,17 +18,15 @@
1818
1919#include <glib.h>
2020#include <glib-object.h>
21−#include <timezonemap/tz.h>
2221
2322#include "LocalePlugin.h"
2423#include "timezonemodel.h"
2524
2625TimeZoneLocationModel::TimeZoneLocationModel(QObject *parent):
2726 QAbstractListModel(parent),
28− m_workerThread(new TimeZonePopulateWorker())
27+ m_listUpdating(false),
28+ m_cancellable(nullptr)
2929{
30− qRegisterMetaType<TzLocationWizard>();
31−
3230 m_roleNames[Qt::DisplayRole] = "displayName";
3331 m_roleNames[TimeZoneRole] = "timeZone";
3432 m_roleNames[CityRole] = "city";
@@ -36,78 +34,52 @@ TimeZoneLocationModel::TimeZoneLocationModel(QObject *parent):
3634 m_roleNames[OffsetRole] = "offset";
3735 m_roleNames[LatitudeRole] = "latitude";
3836 m_roleNames[LongitudeRole] = "longitude";
39−
40− QObject::connect(m_workerThread,
41− &TimeZonePopulateWorker::resultReady,
42− this,
43− &TimeZoneLocationModel::processModelResult);
44− QObject::connect(m_workerThread,
45− &TimeZonePopulateWorker::finished,
46− this,
47− &TimeZoneLocationModel::store);
48− QObject::connect(m_workerThread,
49− &TimeZonePopulateWorker::finished,
50− m_workerThread,
51− &QObject::deleteLater);
52−
53− init();
54−}
55−
56−void TimeZoneLocationModel::init()
57−{
58− beginResetModel();
59− m_workerThread->start();
60−}
61−
62−void TimeZoneLocationModel::store()
63−{
64− m_workerThread = nullptr;
65− endResetModel();
66−}
67−
68−void TimeZoneLocationModel::processModelResult(const TzLocationWizard &location)
69−{
70− m_locations.append(location);
7137}
7238
7339int TimeZoneLocationModel::rowCount(const QModelIndex &parent) const
7440{
75− if (parent.isValid())
41+ if (parent.isValid()) {
7642 return 0;
77− return m_locations.count();
43+ } else if (m_filter.isEmpty()) {
44+ return m_countryLocations.count();
45+ } else {
46+ return m_locations.count();
47+ }
7848}
7949
8050QVariant TimeZoneLocationModel::data(const QModelIndex &index, int role) const
8151{
82− if (index.row() >= m_locations.count() || index.row() < 0)
52+ GeonamesCity *city;
53+ if (m_filter.isEmpty()) {
54+ city = m_countryLocations.value(index.row());
55+ } else {
56+ city = m_locations.value(index.row());
57+ }
58+ if (!city)
8359 return QVariant();
8460
85− const TzLocationWizard tz = m_locations.at(index.row());
86−
87− const QString country(tz.full_country.isEmpty() ? tz.country : tz.full_country);
88−
8961 switch (role) {
9062 case Qt::DisplayRole:
91− if (!tz.state.isEmpty())
92− return QStringLiteral("%1, %2, %3").arg(tz.city).arg(tz.state).arg(country);
93− else
94− return QStringLiteral("%1, %2").arg(tz.city).arg(country);
63+ return QStringLiteral("%1, %2, %3").arg(geonames_city_get_name(city))
64+ .arg(geonames_city_get_state(city))
65+ .arg(geonames_city_get_country(city));
9566 case SimpleRole:
96− return QStringLiteral("%1, %2").arg(tz.city).arg(country);
67+ return QStringLiteral("%1, %2").arg(geonames_city_get_name(city))
68+ .arg(geonames_city_get_country(city));
9769 case TimeZoneRole:
98− return tz.timezone;
70+ return geonames_city_get_timezone(city);
9971 case CountryRole:
100− return tz.country;
72+ return geonames_city_get_country(city);
10173 case CityRole:
102− return tz.city;
74+ return geonames_city_get_name(city);
10375 case OffsetRole: {
104− QTimeZone tmp(tz.timezone.toLatin1());
76+ QTimeZone tmp(geonames_city_get_timezone(city));
10577 return static_cast<double>(tmp.standardTimeOffset(QDateTime::currentDateTime())) / 3600;
10678 }
10779 case LatitudeRole:
108− return tz.latitude;
80+ return geonames_city_get_latitude(city);
10981 case LongitudeRole:
110− return tz.longitude;
82+ return geonames_city_get_longitude(city);
11183 default:
11284 qWarning() << Q_FUNC_INFO << "Unknown role";
11385 return QVariant();
@@ -119,110 +91,149 @@ QHash<int, QByteArray> TimeZoneLocationModel::roleNames() const
11991 return m_roleNames;
12092}
12193
122−void TimeZonePopulateWorker::run()
94+void TimeZoneLocationModel::setModel(const QList<GeonamesCity *> &locations)
12395{
124− buildCityMap();
96+ beginResetModel();
97+
98+ Q_FOREACH(GeonamesCity *city, m_locations) {
99+ geonames_city_free(city);
100+ }
101+
102+ m_locations = locations;
103+ endResetModel();
125104}
126105
127−void TimeZonePopulateWorker::buildCityMap()
106+void TimeZoneLocationModel::filterFinished(GObject *source_object,
107+ GAsyncResult *res,
108+ gpointer user_data)
128109{
129− TzDB *tzdb = tz_load_db();
130− GPtrArray *tz_locations = tz_get_locations(tzdb);
131−
132− TimeZoneLocationModel::TzLocationWizard tmpTz;
133−
134− for (guint i = 0; i < tz_locations->len; ++i) {
135− auto tmp = static_cast<CcTimezoneLocation *>(g_ptr_array_index(tz_locations, i));
136− gchar *en_name, *country, *zone, *state, *full_country;
137− gdouble latitude;
138− gdouble longitude;
139− g_object_get (tmp, "en_name", &en_name,
140− "country", &country,
141− "zone", &zone,
142− "state", &state,
143− "full_country", &full_country,
144− "latitude", &latitude,
145− "longitude", &longitude,
146− nullptr);
147− // There are empty entries in the DB
148− if (g_strcmp0(en_name, "") != 0) {
149− tmpTz.city = en_name;
150− tmpTz.country = country;
151− tmpTz.timezone = zone;
152− tmpTz.state = state;
153− tmpTz.full_country = full_country;
154− tmpTz.latitude = latitude;
155− tmpTz.longitude = longitude;
156−
157− Q_EMIT (resultReady(tmpTz));
110+ Q_UNUSED(source_object);
111+
112+ g_autofree gint *cities = nullptr;
113+ guint cities_len = 0;
114+ g_autoptr(GError) error = nullptr;
115+
116+ cities = geonames_query_cities_finish(res, &cities_len, &error);
117+ if (error) {
118+ if (!g_error_matches(error, G_IO_ERROR, G_IO_ERROR_CANCELLED)) {
119+ TimeZoneLocationModel *model = static_cast<TimeZoneLocationModel *>(user_data);
120+ g_clear_object(&model->m_cancellable);
121+ model->setListUpdating(false);
122+ qWarning() << "Could not filter timezones:" << error->message;
158123 }
159− g_free (en_name);
160− g_free (country);
161− g_free (zone);
162− g_free (state);
163− g_free (full_country);
124+ return;
164125 }
165126
166− g_ptr_array_free (tz_locations, TRUE);
167− tz_db_free(tzdb);
168−}
127+ QList<GeonamesCity *> locations;
169128
129+ for (guint i = 0; i < cities_len; ++i) {
130+ GeonamesCity *city = geonames_get_city(cities[i]);
131+ if (city) {
132+ locations.append(city);
133+ }
134+ }
170135
171−TimeZoneFilterModel::TimeZoneFilterModel(QObject *parent)
172− : QSortFilterProxyModel(parent)
173−{
174− setDynamicSortFilter(false);
175− setSortLocaleAware(true);
176− setSortRole(TimeZoneLocationModel::CityRole);
177− m_stringMatcher.setCaseSensitivity(Qt::CaseInsensitive);
178− sort(0);
136+ TimeZoneLocationModel *model = static_cast<TimeZoneLocationModel *>(user_data);
137+
138+ g_clear_object(&model->m_cancellable);
139+
140+ model->setModel(locations);
141+ model->setListUpdating(false);
179142}
180143
181−bool TimeZoneFilterModel::filterAcceptsRow(int row, const QModelIndex &parentIndex) const
144+bool TimeZoneLocationModel::listUpdating() const
182145{
183− if (!sourceModel()) {
184− return true;
185− }
186−
187− if (!m_filter.isEmpty()) { // filtering by freeform text input, cf setFilter(QString)
188− const QString city = sourceModel()->index(row, 0, parentIndex).data(TimeZoneLocationModel::CityRole).toString();
146+ return m_listUpdating;
147+}
189148
190− if (m_stringMatcher.indexIn(city) == 0) { // match at the beginning of the city name
191− return true;
192− }
193− } else if (!m_country.isEmpty()) { // filter by country code
194− const QString countryCode = sourceModel()->index(row, 0, parentIndex).data(TimeZoneLocationModel::CountryRole).toString();
195− return m_country.compare(countryCode, Qt::CaseInsensitive) == 0;
149+void TimeZoneLocationModel::setListUpdating(bool listUpdating)
150+{
151+ if (m_listUpdating != listUpdating) {
152+ m_listUpdating = listUpdating;
153+ Q_EMIT listUpdatingChanged();
196154 }
197−
198− return false;
199155}
200156
201−QString TimeZoneFilterModel::filter() const
157+QString TimeZoneLocationModel::filter() const
202158{
203159 return m_filter;
204160}
205161
206−void TimeZoneFilterModel::setFilter(const QString &filter)
162+void TimeZoneLocationModel::setFilter(const QString &filter)
207163{
208164 if (filter != m_filter) {
209165 m_filter = filter;
210− m_stringMatcher.setPattern(m_filter);
211166 Q_EMIT filterChanged();
212− invalidate();
213167 }
168+
169+ setListUpdating(true);
170+
171+ if (m_cancellable) {
172+ g_cancellable_cancel(m_cancellable);
173+ g_clear_object(&m_cancellable);
174+ }
175+
176+ setModel(QList<GeonamesCity *>());
177+
178+ if (filter.isEmpty()) {
179+ setListUpdating(false);
180+ return;
181+ }
182+
183+ m_cancellable = g_cancellable_new();
184+ geonames_query_cities(filter.toUtf8().data(),
185+ GEONAMES_QUERY_DEFAULT,
186+ m_cancellable,
187+ filterFinished,
188+ this);
214189}
215190
216−QString TimeZoneFilterModel::country() const
191+QString TimeZoneLocationModel::country() const
217192{
218193 return m_country;
219194}
220195
221−void TimeZoneFilterModel::setCountry(const QString &country)
196+static bool citycmp(GeonamesCity *a, GeonamesCity *b)
197+{
198+ return geonames_city_get_population(b) < geonames_city_get_population(a);
199+}
200+
201+void TimeZoneLocationModel::setCountry(const QString &country)
222202{
223203 if (m_country == country)
224204 return;
225205
226206 m_country = country;
207+
208+ Q_FOREACH(GeonamesCity *city, m_countryLocations) {
209+ geonames_city_free(city);
210+ }
211+
212+ gint num_cities = geonames_get_n_cities();
213+ for (gint i = 0; i < num_cities; i++) {
214+ GeonamesCity *city = geonames_get_city(i);
215+ if (city && m_country == geonames_city_get_country_code(city)) {
216+ m_countryLocations.append(city);
217+ }
218+ }
219+
220+ std::sort(m_countryLocations.begin(), m_countryLocations.end(), citycmp);
221+
227222 Q_EMIT countryChanged(country);
228223}
224+
225+TimeZoneLocationModel::~TimeZoneLocationModel()
226+{
227+ if (m_cancellable) {
228+ g_cancellable_cancel(m_cancellable);
229+ g_clear_object(&m_cancellable);
230+ }
231+
232+ Q_FOREACH(GeonamesCity *city, m_countryLocations) {
233+ geonames_city_free(city);
234+ }
235+
236+ Q_FOREACH(GeonamesCity *city, m_locations) {
237+ geonames_city_free(city);
238+ }
239+}