← Back to branch summary

~ubuntu-branches/ubuntu/saucy/hud/saucy-proposed

« back to all changes in this revision

Viewing changes to src/huddbusmenucollector.c

  • Committer: Package Import Robot
  • Author(s): Ubuntu daily release
  • Date: 2013-06-05 12:33:44 UTC
  • mto: This revision was merged to the branch mainline in revision 5.
  • Revision ID: package-import@ubuntu.com-20130605123344-cpp4to647tyfv7kr
Tags: upstream-13.10.1daily13.06.05.1
Import upstream version 13.10.1daily13.06.05.1

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/huddbusmenucollector.c
27
27
#include "hudappmenuregistrar.h"
28
28
#include "hudresult.h"
29
29
#include "hudsource.h"
 
30
#include "hudkeywordmapping.h"
30
31
 
31
32
/**
32
33
 * SECTION:huddbusmenucollector
155
156
  return g_hash_table_lookup (property_hash, type);
156
157
}
157
158
 
 
159
/* Check to see if a Dbusmenu Menuitem has a shortcut, and if
 
160
   so make it into a pretty string. */
 
161
static gchar *
 
162
shortcut_string_for_menuitem (DbusmenuMenuitem * mi)
 
163
{
 
164
        if (!dbusmenu_menuitem_property_exist(mi, DBUSMENU_MENUITEM_PROP_SHORTCUT)) {
 
165
                return g_strdup("");
 
166
        }
 
167
 
 
168
        GVariant * shortcut = dbusmenu_menuitem_property_get_variant(mi, DBUSMENU_MENUITEM_PROP_SHORTCUT);
 
169
        GString * output = g_string_new("");
 
170
        gint keypress = 0;
 
171
 
 
172
        for (keypress = 0; keypress < g_variant_n_children(shortcut); keypress++) {
 
173
                GVariant * key = g_variant_get_child_value(shortcut, keypress);
 
174
 
 
175
                if (output->len > 0) {
 
176
                        g_string_append(output, ", ");
 
177
                }
 
178
 
 
179
                int subkey = 0;
 
180
                for (subkey = 0; subkey < g_variant_n_children(key); subkey++) {
 
181
                        GVariant * skeyv = g_variant_get_child_value(key, subkey);
 
182
                        const gchar * button = g_variant_get_string(skeyv, NULL);
 
183
                        g_variant_unref(skeyv); /* We can do this because we know it's parent is held, and this makes things a bit cleaner further down */
 
184
 
 
185
                        if (g_strcmp0(button, DBUSMENU_MENUITEM_SHORTCUT_ALT) == 0) {
 
186
                                g_string_append(output, "Alt + ");
 
187
                        } else if (g_strcmp0(button, DBUSMENU_MENUITEM_SHORTCUT_CONTROL) == 0) {
 
188
                                g_string_append(output, "Ctrl + ");
 
189
                        } else if (g_strcmp0(button, DBUSMENU_MENUITEM_SHORTCUT_SHIFT) == 0) {
 
190
                                g_string_append(output, "Shift + ");
 
191
                        } else if (g_strcmp0(button, DBUSMENU_MENUITEM_SHORTCUT_SUPER) == 0) {
 
192
                                g_string_append(output, "Super + "); /* TODO: Can we detect if this is Apple or Windows or Ubuntu? */
 
193
                        } else {
 
194
                                g_string_append(output, button);
 
195
                        }
 
196
                }
 
197
 
 
198
                g_variant_unref(key);
 
199
        }
 
200
 
 
201
        return g_string_free(output, FALSE);
 
202
}
158
203
 
159
204
static HudDbusmenuItem *
160
205
hud_dbusmenu_item_new (HudStringList    *context,
161
 
                       const gchar      *desktop_file,
 
206
                       const gchar      *application_id,
162
207
                       const gchar      *icon,
 
208
                       HudKeywordMapping *keyword_mapping,
163
209
                       DbusmenuMenuitem *menuitem)
164
210
{
165
 
  HudStringList *tokens;
 
211
  HudStringList *full_label, *keywords;
166
212
  HudDbusmenuItem *item;
167
213
  const gchar *type;
168
214
  const gchar *prop;
 
215
  gchar *shortcut;
169
216
  gboolean enabled;
170
217
 
171
218
  type = dbusmenu_menuitem_property_get (menuitem, DBUSMENU_MENUITEM_PROP_TYPE);
172
219
  prop = hud_dbusmenu_item_get_label_property (type);
 
220
  shortcut = shortcut_string_for_menuitem(menuitem);
173
221
 
174
222
  if (prop && dbusmenu_menuitem_property_exist (menuitem, prop))
175
223
    {
176
224
      const gchar *label;
 
225
      gint i;
177
226
 
178
227
      label = dbusmenu_menuitem_property_get (menuitem, prop);
179
 
      tokens = hud_string_list_cons_label (label, context);
 
228
      full_label = hud_string_list_cons_label (label, context);
 
229
      keywords = NULL;
 
230
      GPtrArray *mapping = hud_keyword_mapping_transform(keyword_mapping, label);
 
231
      for (i = 0; i < mapping->len; i++)
 
232
      {
 
233
        keywords = hud_string_list_cons_label (
 
234
            (gchar*) g_ptr_array_index(mapping, i), keywords);
 
235
      }
180
236
      enabled = TRUE;
181
237
    }
182
238
  else
183
239
    {
184
 
      tokens = hud_string_list_ref (context);
 
240
      full_label = hud_string_list_ref (context);
 
241
      keywords = NULL;
185
242
      enabled = FALSE;
186
243
    }
187
244
 
196
253
  if (enabled)
197
254
    enabled &= !dbusmenu_menuitem_property_exist (menuitem, DBUSMENU_MENUITEM_PROP_CHILD_DISPLAY);
198
255
 
199
 
  item = hud_item_construct (hud_dbusmenu_item_get_type (), tokens, desktop_file, icon, enabled);
 
256
  item = hud_item_construct (hud_dbusmenu_item_get_type (), full_label, keywords, shortcut, application_id, icon, NULL, enabled);
200
257
  item->menuitem = g_object_ref (menuitem);
201
258
 
202
 
  hud_string_list_unref (tokens);
 
259
  hud_string_list_unref (full_label);
 
260
  hud_string_list_unref (keywords);
 
261
  g_free(shortcut);
203
262
 
204
263
  return item;
205
264
}
219
278
  gboolean alive;
220
279
  gint use_count;
221
280
  gboolean reentrance_check;
 
281
  HudKeywordMapping* keyword_mapping;
 
282
  HudSourceItemType type;
222
283
};
223
284
 
224
285
typedef GObjectClass HudDbusmenuCollectorClass;
225
286
 
226
287
static void hud_dbusmenu_collector_iface_init (HudSourceInterface *iface);
 
288
static GList * hud_dbusmenu_collector_get_items (HudSource * source);
 
289
const gchar * hud_dbusmenu_collector_get_app_id (HudSource *collector);
 
290
static const gchar * hud_dbusmenu_collector_get_app_icon (HudSource *collector);
 
291
 
227
292
G_DEFINE_TYPE_WITH_CODE (HudDbusmenuCollector, hud_dbusmenu_collector, G_TYPE_OBJECT,
228
293
                         G_IMPLEMENT_INTERFACE (HUD_TYPE_SOURCE, hud_dbusmenu_collector_iface_init))
229
294
 
291
356
 
292
357
static void
293
358
hud_dbusmenu_collector_search (HudSource    *source,
294
 
                               GPtrArray    *results_array,
295
 
                               HudTokenList *search_string)
 
359
                               HudTokenList *search_string,
 
360
                               void        (*append_func) (HudResult * result, gpointer user_data),
 
361
                               gpointer      user_data)
296
362
{
297
363
  HudDbusmenuCollector *collector = HUD_DBUSMENU_COLLECTOR (source);
298
364
  GHashTableIter iter;
305
371
 
306
372
      result = hud_result_get_if_matched (item, search_string, collector->penalty);
307
373
      if (result)
308
 
        g_ptr_array_add (results_array, result);
309
 
    }
 
374
        append_func(result, user_data);
 
375
    }
 
376
}
 
377
 
 
378
static void
 
379
hud_dbusmenu_collector_list_application (HudSource    *source,
 
380
                                         HudTokenList *search_string,
 
381
                                         void        (*append_func) (const gchar *application_id, const gchar *application_icon, HudSourceItemType type, gpointer user_data),
 
382
                                         gpointer      user_data)
 
383
{
 
384
  HudDbusmenuCollector *collector = HUD_DBUSMENU_COLLECTOR (source);
 
385
  GHashTableIter iter;
 
386
  gpointer item;
 
387
 
 
388
  g_hash_table_iter_init (&iter, collector->items);
 
389
  while (g_hash_table_iter_next (&iter, NULL, &item))
 
390
    {
 
391
      HudResult *result;
 
392
 
 
393
      result = hud_result_get_if_matched (item, search_string, collector->penalty);
 
394
      if (result) {
 
395
        append_func(collector->application_id, collector->icon, collector->type, user_data);
 
396
        g_object_unref(result);
 
397
        break;
 
398
      }
 
399
    }
 
400
}
 
401
 
 
402
 
 
403
static HudSource *
 
404
hud_dbusmenu_collector_get (HudSource     *source,
 
405
                            const gchar   *application_id)
 
406
{
 
407
  HudDbusmenuCollector *collector = HUD_DBUSMENU_COLLECTOR (source);
 
408
 
 
409
  if (g_strcmp0 (application_id, collector->application_id) == 0)
 
410
    return source;
 
411
 
 
412
  return NULL;
310
413
}
311
414
 
312
415
static void
379
482
  was_open = item->is_opened;
380
483
  g_hash_table_remove (collector->items, menuitem);
381
484
 
382
 
  item = hud_dbusmenu_item_new (context, collector->application_id, collector->icon, menuitem);
 
485
  item = hud_dbusmenu_item_new (context, collector->application_id,
 
486
      collector->icon, collector->keyword_mapping, menuitem);
383
487
 
384
488
  if (collector->use_count && !was_open && dbusmenu_menuitem_property_exist (menuitem, DBUSMENU_MENUITEM_PROP_CHILD_DISPLAY))
385
489
    {
400
504
  HudDbusmenuItem *item;
401
505
  GList *child;
402
506
 
403
 
  item = hud_dbusmenu_item_new (context, collector->application_id, collector->icon, menuitem);
 
507
  item = hud_dbusmenu_item_new (context, collector->application_id,
 
508
      collector->icon, collector->keyword_mapping, menuitem);
404
509
  context = hud_item_get_tokens (HUD_ITEM (item));
405
510
 
406
511
  g_signal_connect (menuitem, "property-changed", G_CALLBACK (hud_dbusmenu_collector_property_changed), collector);
532
637
 
533
638
  g_free (collector->application_id);
534
639
  g_free (collector->icon);
 
640
  g_object_unref (collector->keyword_mapping);
535
641
 
536
642
  hud_string_list_unref (collector->prefix);
537
643
  g_clear_object (&collector->client);
538
644
 
 
645
  g_clear_object (&collector->root);
 
646
 
539
647
  G_OBJECT_CLASS (hud_dbusmenu_collector_parent_class)
540
648
    ->finalize (object);
541
649
}
552
660
  iface->use = hud_dbusmenu_collector_use;
553
661
  iface->unuse = hud_dbusmenu_collector_unuse;
554
662
  iface->search = hud_dbusmenu_collector_search;
 
663
  iface->list_applications = hud_dbusmenu_collector_list_application;
 
664
  iface->get = hud_dbusmenu_collector_get;
 
665
  iface->get_items = hud_dbusmenu_collector_get_items;
 
666
  iface->get_app_id = hud_dbusmenu_collector_get_app_id;
 
667
  iface->get_app_icon = hud_dbusmenu_collector_get_app_icon;
555
668
}
556
669
 
557
670
static void
558
671
hud_dbusmenu_collector_class_init (HudDbusmenuCollectorClass *class)
559
672
{
560
 
  class->finalize = hud_dbusmenu_collector_finalize;
 
673
  GObjectClass * gclass = G_OBJECT_CLASS(class);
 
674
  gclass->finalize = hud_dbusmenu_collector_finalize;
561
675
}
562
676
 
563
677
/**
592
706
                                         const gchar *icon,
593
707
                                         guint        penalty,
594
708
                                         const gchar *bus_name,
595
 
                                         const gchar *object_path)
 
709
                                         const gchar *object_path,
 
710
                                         HudSourceItemType type)
596
711
{
597
712
  HudDbusmenuCollector *collector;
598
713
 
599
714
  collector = g_object_new (HUD_TYPE_DBUSMENU_COLLECTOR, NULL);
600
715
  collector->application_id = g_strdup (application_id);
601
716
  collector->icon = g_strdup (icon);
 
717
  collector->type = type;
602
718
  if (prefix)
603
719
    collector->prefix = hud_string_list_cons (prefix, NULL);
604
720
  collector->penalty = penalty;
605
721
  hud_dbusmenu_collector_setup_endpoint (collector, bus_name, object_path);
 
722
  collector->keyword_mapping = hud_keyword_mapping_new();
 
723
  hud_keyword_mapping_load(collector->keyword_mapping, collector->application_id, DATADIR, GNOMELOCALEDIR);
606
724
 
607
725
  collector->alive = TRUE;
608
726
 
621
739
 * Returns: a new #HudDbusmenuCollector
622
740
 **/
623
741
HudDbusmenuCollector *
624
 
hud_dbusmenu_collector_new_for_window (BamfWindow  *window,
625
 
                                       const gchar *desktop_file,
626
 
                                       const gchar *icon)
 
742
hud_dbusmenu_collector_new_for_window (AbstractWindow  *window,
 
743
                                       const gchar *application_id,
 
744
                                       const gchar *icon,
 
745
                                       HudSourceItemType type)
627
746
{
628
747
  HudDbusmenuCollector *collector;
629
748
 
630
749
  collector = g_object_new (HUD_TYPE_DBUSMENU_COLLECTOR, NULL);
631
 
  collector->application_id = g_strdup (desktop_file);
 
750
  collector->application_id = g_strdup (application_id);
632
751
  collector->icon = g_strdup (icon);
 
752
  collector->type = type;
 
753
  collector->xid = 0;
 
754
#ifdef HAVE_BAMF
633
755
  collector->xid = bamf_window_get_xid (window);
 
756
#endif
 
757
#ifdef HAVE_PLATFORM_API
 
758
  collector->xid = _ubuntu_ui_session_properties_get_window_id(window);
 
759
#endif
 
760
  collector->keyword_mapping = hud_keyword_mapping_new();
 
761
  hud_keyword_mapping_load(collector->keyword_mapping, collector->application_id, DATADIR, GNOMELOCALEDIR);
 
762
 
634
763
  g_debug ("dbusmenu on %d", collector->xid);
635
764
  hud_app_menu_registrar_add_observer (hud_app_menu_registrar_get (), collector->xid,
636
765
                                       hud_dbusmenu_collector_registrar_observer_func, collector);
677
806
  collector->icon = g_strdup (icon);
678
807
  hud_dbusmenu_collector_setup_root (collector, collector->root);
679
808
}
 
809
 
 
810
/**
 
811
 * hud_dbusmenu_collector_get_items:
 
812
 * @collector: a #HudDbusmenuCollector
 
813
 *
 
814
 * Gets the items that have been collected at any point in time.
 
815
 *
 
816
 * Return Value: (element-type HudItem) (transfer full) A list of #HudItem
 
817
 * objects.  Free with g_list_free_full(g_object_unref)
 
818
 */
 
819
static GList *
 
820
hud_dbusmenu_collector_get_items (HudSource * source)
 
821
{
 
822
  g_return_val_if_fail(HUD_IS_DBUSMENU_COLLECTOR(source), NULL);
 
823
  HudDbusmenuCollector * dcollector = HUD_DBUSMENU_COLLECTOR(source);
 
824
 
 
825
  GList * hashvals = g_hash_table_get_values (dcollector->items);
 
826
 
 
827
  return g_list_copy_deep (hashvals, (GCopyFunc) g_object_ref, NULL );
 
828
}
 
829
 
 
830
/**
 
831
 * hud_dbusmenu_collector_get_app_id:
 
832
 * @collector: a #HudDbusmenuCollector
 
833
 *
 
834
 * Gets the ID of the collected application
 
835
 *
 
836
 * Return value: Application ID
 
837
 */
 
838
const gchar *
 
839
hud_dbusmenu_collector_get_app_id (HudSource *collector)
 
840
{
 
841
        g_return_val_if_fail(HUD_IS_DBUSMENU_COLLECTOR(collector), NULL);
 
842
        return HUD_DBUSMENU_COLLECTOR(collector)->application_id;
 
843
}
 
844
 
 
845
/**
 
846
 * hud_dbusmenu_collector_get_app_icon:
 
847
 * @collector: a #HudDbusmenuCollector
 
848
 *
 
849
 * Gets the icon of the collected application
 
850
 *
 
851
 * Return value: Application icon
 
852
 */
 
853
static const gchar *
 
854
hud_dbusmenu_collector_get_app_icon (HudSource *collector)
 
855
{
 
856
        g_return_val_if_fail(HUD_IS_DBUSMENU_COLLECTOR(collector), NULL);
 
857
        return HUD_DBUSMENU_COLLECTOR(collector)->icon;
 
858
}