← Back to branch summary

~azzar1/unity/fix-681503

« back to all changes in this revision

Viewing changes to UnityCore/Lens.cpp

  • Committer: Andrea Azzarone
  • Date: 2012-01-18 13:28:09 UTC
  • mfrom: (1815.1.29 unity)
  • Revision ID: azzaronea@gmail.com-20120118132809-5pdgbnq1bgtitoz2
Merge trunk.

Show diffs side-by-side

added added

removed removed

Lines of Context:
UnityCore/Lens.cpp
26
26
#include "config.h"
27
27
#include "GLibDBusProxy.h"
28
28
#include "GLibWrapper.h"
29
 
#include "Utils.h"
30
29
 
31
30
namespace unity
32
31
{
59
58
  void OnProxyConnected();
60
59
  void OnProxyDisconnected();
61
60
 
 
61
  void ResultsModelUpdated(unsigned long long begin_seqnum, 
 
62
                           unsigned long long end_seqnum);
 
63
  void GlobalResultsModelUpdated(unsigned long long begin_seqnum,
 
64
                                 unsigned long long end_seqnum);
 
65
 
 
66
  unsigned long long ExtractModelSeqnum(GVariant *parameters);
 
67
 
62
68
  void OnSearchFinished(GVariant* parameters);
63
69
  void OnGlobalSearchFinished(GVariant* parameters);
64
70
  void OnChanged(GVariant* parameters);
118
124
  glib::DBusProxy proxy_;
119
125
  glib::Object<GCancellable> search_cancellable_;
120
126
  glib::Object<GCancellable> global_search_cancellable_;
 
127
 
 
128
  GVariant *results_variant_;
 
129
  GVariant *global_results_variant_;
121
130
};
122
131
 
123
132
Lens::Impl::Impl(Lens* owner,
147
156
  , filters_(new Filters())
148
157
  , connected_(false)
149
158
  , proxy_(dbus_name, dbus_path, "com.canonical.Unity.Lens")
 
159
  , results_variant_(NULL)
 
160
  , global_results_variant_(NULL)
150
161
{
151
162
  proxy_.connected.connect(sigc::mem_fun(this, &Lens::Impl::OnProxyConnected));
152
163
  proxy_.disconnected.connect(sigc::mem_fun(this, &Lens::Impl::OnProxyDisconnected));
153
164
  proxy_.Connect("Changed", sigc::mem_fun(this, &Lens::Impl::OnChanged));
 
165
  results_->end_transaction.connect(sigc::mem_fun(this, &Lens::Impl::ResultsModelUpdated));
 
166
  global_results_->end_transaction.connect(sigc::mem_fun(this, &Lens::Impl::GlobalResultsModelUpdated));
154
167
}
155
168
 
156
169
Lens::Impl::~Impl()
178
191
  owner_->connected.EmitChanged(connected_);
179
192
}
180
193
 
 
194
void Lens::Impl::ResultsModelUpdated(unsigned long long begin_seqnum,
 
195
                                     unsigned long long end_seqnum)
 
196
{
 
197
  if (results_variant_ != NULL &&
 
198
      end_seqnum >= ExtractModelSeqnum (results_variant_))
 
199
  {
 
200
    glib::Variant dict(results_variant_, glib::StealRef());
 
201
    Hints hints;
 
202
 
 
203
    dict.ASVToHints(hints);
 
204
 
 
205
    owner_->search_finished.emit(hints);
 
206
 
 
207
    results_variant_ = NULL;
 
208
  }
 
209
}
 
210
 
 
211
void Lens::Impl::GlobalResultsModelUpdated(unsigned long long begin_seqnum,
 
212
                                           unsigned long long end_seqnum)
 
213
{
 
214
  if (global_results_variant_ != NULL &&
 
215
      end_seqnum >= ExtractModelSeqnum (global_results_variant_))
 
216
  {
 
217
    glib::Variant dict(global_results_variant_, glib::StealRef());
 
218
    Hints hints;
 
219
 
 
220
    dict.ASVToHints(hints);
 
221
 
 
222
    owner_->global_search_finished.emit(hints);
 
223
 
 
224
    global_results_variant_ = NULL;
 
225
  }
 
226
}
 
227
 
 
228
unsigned long long Lens::Impl::ExtractModelSeqnum(GVariant *parameters)
 
229
{
 
230
  GVariant *dict;
 
231
  guint64 seqnum64;
 
232
  unsigned long long seqnum = 0;
 
233
 
 
234
  dict = g_variant_get_child_value (parameters, 0);
 
235
  if (dict)
 
236
  {
 
237
    if (g_variant_lookup (dict, "model-seqnum", "t", &seqnum64))
 
238
    {
 
239
      seqnum = static_cast<unsigned long long> (seqnum64);
 
240
    }
 
241
 
 
242
    g_variant_unref (dict);
 
243
  }
 
244
 
 
245
  return seqnum;
 
246
}
 
247
 
181
248
void Lens::Impl::OnSearchFinished(GVariant* parameters)
182
249
{
183
 
  GVariantIter* hints_iter;
184
250
  Hints hints;
185
 
  
186
 
  g_variant_get(parameters, "(a{sv})", &hints_iter);
187
 
  
188
 
  Utils::ASVToHints(hints, hints_iter);
189
 
 
190
 
  // FIXME: make sure the model is updated, wait if it isn't (once Dee supports
191
 
  // that)
 
251
  unsigned long long reply_seqnum;
 
252
 
 
253
  reply_seqnum = ExtractModelSeqnum (parameters);
 
254
  if (results_->seqnum < reply_seqnum)
 
255
  {
 
256
    // wait for the end-transaction signal
 
257
    if (results_variant_) g_variant_unref (results_variant_);
 
258
    results_variant_ = g_variant_ref (parameters);
 
259
 
 
260
    // ResultsModelUpdated will emit OnSearchFinished
 
261
    return;
 
262
  }
 
263
 
 
264
  glib::Variant dict (parameters);
 
265
  dict.ASVToHints(hints);
 
266
 
192
267
  owner_->search_finished.emit(hints);
193
 
 
194
 
  g_variant_iter_free(hints_iter);
195
268
}
196
269
 
197
270
void Lens::Impl::OnGlobalSearchFinished(GVariant* parameters)
198
271
{
199
 
  GVariantIter* hints_iter;
200
272
  Hints hints;
201
 
  
202
 
  g_variant_get(parameters, "(a{sv})", &hints_iter);
203
 
  
204
 
  Utils::ASVToHints(hints, hints_iter);
 
273
  unsigned long long reply_seqnum;
 
274
  
 
275
  reply_seqnum = ExtractModelSeqnum (parameters);
 
276
  if (global_results_->seqnum < reply_seqnum)
 
277
  {
 
278
    // wait for the end-transaction signal
 
279
    if (global_results_variant_) g_variant_unref (global_results_variant_);
 
280
    global_results_variant_ = g_variant_ref (parameters);
 
281
 
 
282
    // GlobalResultsModelUpdated will emit OnGlobalSearchFinished
 
283
    return;
 
284
  }
 
285
 
 
286
  glib::Variant dict (parameters);
 
287
  dict.ASVToHints(hints);
205
288
 
206
289
  owner_->global_search_finished.emit(hints);
207
 
 
208
 
  g_variant_iter_free(hints_iter);
209
290
}
210
291
 
211
292
void Lens::Impl::OnChanged(GVariant* parameters)
320
401
    g_cancellable_cancel (global_search_cancellable_);
321
402
  global_search_cancellable_ = g_cancellable_new ();
322
403
 
 
404
  if (global_results_variant_)
 
405
  {
 
406
    g_variant_unref (global_results_variant_);
 
407
    global_results_variant_ = NULL;
 
408
  }
 
409
 
323
410
  proxy_.Call("GlobalSearch",
324
411
              g_variant_new("(sa{sv})",
325
412
                            search_string.c_str(),
339
426
  if (search_cancellable_) g_cancellable_cancel (search_cancellable_);
340
427
  search_cancellable_ = g_cancellable_new ();
341
428
 
 
429
  if (results_variant_)
 
430
  {
 
431
    g_variant_unref (results_variant_);
 
432
    results_variant_ = NULL;
 
433
  }
 
434
 
342
435
  proxy_.Call("Search",
343
436
              g_variant_new("(sa{sv})",
344
437
                            search_string.c_str(),
362
455
{
363
456
  glib::String uri;
364
457
  guint32 handled;
365
 
  GVariantIter* hints_iter;
 
458
  GVariant* hints_variant;
366
459
  Hints hints;
367
460
  
368
 
  g_variant_get(parameters, "((sua{sv}))", &uri, &handled, &hints_iter);
369
 
  
370
 
  Utils::ASVToHints(hints, hints_iter);
 
461
  g_variant_get(parameters, "((su@a{sv}))", &uri, &handled, &hints_variant);
 
462
 
 
463
  glib::Variant dict (hints_variant, glib::StealRef());
 
464
  dict.ASVToHints(hints);
371
465
 
372
466
  owner_->activated.emit(uri.Str(), static_cast<HandledType>(handled), hints);
373
 
 
374
 
  g_variant_iter_free(hints_iter);
375
467
}
376
468
 
377
469
void Lens::Impl::Preview(std::string const& uri)
387
479
{
388
480
  glib::String uri;
389
481
  glib::String renderer_name;
390
 
  GVariantIter* hints_iter;
 
482
  GVariant* hints_variant;
391
483
  Hints hints;
392
484
  
393
 
  g_variant_get(parameters, "((ssa{sv}))", &uri, &renderer_name, &hints_iter);
394
 
  Utils::ASVToHints(hints, hints_iter);
 
485
  g_variant_get(parameters, "((ss@a{sv}))", &uri, &renderer_name, &hints_variant);
 
486
 
 
487
  glib::Variant dict (hints_variant, glib::StealRef());
 
488
  dict.ASVToHints(hints);
395
489
 
396
490
  Preview::Ptr preview = Preview::PreviewForProperties(renderer_name.Str(), hints);
397
491
  owner_->preview_ready.emit(uri.Str(), preview);
398
 
 
399
 
  g_variant_iter_free(hints_iter);
400
492
}
401
493
string const& Lens::Impl::id() const
402
494
{