diff -Nru zeitgeist-datahub-0.8.2/debian/changelog zeitgeist-datahub-0.8.2/debian/changelog --- zeitgeist-datahub-0.8.2/debian/changelog 2012-03-21 10:28:54.000000000 +0000 +++ zeitgeist-datahub-0.8.2/debian/changelog 2012-04-06 08:21:47.000000000 +0000 @@ -1,3 +1,11 @@ +zeitgeist-datahub (0.8.2-1ubuntu2) precise; urgency=low + + * debian/patches/pre_populator.patch: + - prepopulate zeitgeist results in ubuntu to avoid having an empty unity + home dash in a new session (LP: #962265) + + -- Didier Roche Fri, 06 Apr 2012 10:21:47 +0200 + zeitgeist-datahub (0.8.2-1ubuntu1) precise; urgency=low * Merged against debian. Remaining changes: diff -Nru zeitgeist-datahub-0.8.2/debian/patches/pre_populator.patch zeitgeist-datahub-0.8.2/debian/patches/pre_populator.patch --- zeitgeist-datahub-0.8.2/debian/patches/pre_populator.patch 1970-01-01 00:00:00.000000000 +0000 +++ zeitgeist-datahub-0.8.2/debian/patches/pre_populator.patch 2012-04-11 12:03:41.000000000 +0000 @@ -0,0 +1,1336 @@ +=== modified file 'src/Makefile.am' +Index: zeitgeist-datahub-0.8.2/src/Makefile.am +=================================================================== +--- zeitgeist-datahub-0.8.2.orig/src/Makefile.am 2012-03-07 09:18:29.000000000 +0100 ++++ zeitgeist-datahub-0.8.2/src/Makefile.am 2012-04-11 14:01:04.665264344 +0200 +@@ -23,6 +23,7 @@ + downloads-directory-provider.vala \ + kde-recent-document-provider.vala \ + recent-manager-provider.vala \ ++ pre-populator.vala \ + utils.vala \ + zeitgeist-datahub.vala \ + $(optional_zeitgeist_datahub_SOURCES) \ +Index: zeitgeist-datahub-0.8.2/src/pre-populator.vala +=================================================================== +--- /dev/null 1970-01-01 00:00:00.000000000 +0000 ++++ zeitgeist-datahub-0.8.2/src/pre-populator.vala 2012-04-11 14:01:04.669264362 +0200 +@@ -0,0 +1,117 @@ ++/* ++ * Copyright (C) 2012 Canonical Ltd. ++ * ++ * This program is free software: you can redistribute it and/or modify ++ * it under the terms of the GNU Lesser General Public License as published by ++ * the Free Software Foundation, either version 3 of the License, or ++ * (at your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++ * GNU Lesser General Public License for more details. ++ * ++ * You should have received a copy of the GNU Lesser General Public License ++ * along with this program. If not, see . ++ * ++ * Authored by Michal Hruby ++ * ++ */ ++ ++using Zeitgeist; ++ ++public class PrePopulator : DataProvider ++{ ++ public PrePopulator (DataHub datahub) ++ { ++ GLib.Object (unique_id: "com.canonical,datahub,pre-populator", ++ name: "Pre-populate the log", ++ description: "Pushes a couple of events so Ubuntu Dash home is not empty when doing new install", ++ datahub: datahub); ++ } ++ ++ // if vala didn't have bug in construct-only properties, the properties ++ // would be construct-only ++ public override string unique_id { get; construct set; } ++ public override string name { get; construct set; } ++ public override string description { get; construct set; } ++ ++ public override DataHub datahub { get; construct set; } ++ public override bool enabled { get; set; default = true; } ++ public override bool register { get; construct set; default = true; } ++ ++ construct ++ { ++ } ++ ++ public override void start () ++ { ++ this.prepare_events.begin (); ++ } ++ ++ private Event event_for_desktop_file (string desktop_file, int64 timestamp) ++ { ++ var event = new Event (); ++ event.set_timestamp (timestamp); ++ var subject = new Subject (); ++ ++ event.set_actor ("application://zeitgeist-datahub.desktop"); ++ event.set_interpretation (Zeitgeist.ZG_ACCESS_EVENT); ++ event.set_manifestation (Zeitgeist.ZG_USER_ACTIVITY); ++ event.add_subject (subject); ++ ++ subject.set_uri ("application://%s".printf (desktop_file)); ++ subject.set_interpretation (Zeitgeist.NFO_SOFTWARE); ++ subject.set_manifestation (Zeitgeist.NFO_SOFTWARE_ITEM); ++ subject.set_mimetype ("application/x-desktop"); ++ ++ return event; ++ } ++ ++ private async void prepare_events () ++ { ++ var arr = new GenericArray (); ++ var ts = Timestamp.now (); ++ // the timestamp is in milliseconds, we can safely increment it ++ // (dash will display latest first) ++ arr.add (event_for_desktop_file ("rhythmbox.desktop", ++ts)); ++ arr.add (event_for_desktop_file ("gcalctool.desktop", ++ts)); ++ arr.add (event_for_desktop_file ("gedit.desktop", ++ts)); ++ arr.add (event_for_desktop_file ("totem.desktop", ++ts)); ++ arr.add (event_for_desktop_file ("thunderbird.desktop", ++ts)); ++ arr.add (event_for_desktop_file ("yelp.desktop", ++ts)); ++ ++ try ++ { ++ var log = new Zeitgeist.Log (); ++ var ids = yield log.find_event_ids (new TimeRange.anytime (), ++ new PtrArray (), ++ StorageState.ANY, ++ 1, ++ ResultType.MOST_RECENT_EVENTS, ++ null); ++ ++ if (ids.length == 0) ++ { ++ // pre-populate only if there are no events at all ++ items_available (arr); ++ ++ Timeout.add_seconds (5, prepare_events.callback); ++ yield; ++ } ++ ++ var registry = new DataSourceRegistry (); ++ // this is one-time only module, disable ourselves when done ++ yield registry.set_data_source_enabled (unique_id, false, null); ++ } ++ catch (Error err) ++ { ++ warning ("%s", err.message); ++ } ++ } ++ ++ public override void stop () ++ { ++ } ++} ++ +Index: zeitgeist-datahub-0.8.2/src/zeitgeist-datahub.vala +=================================================================== +--- zeitgeist-datahub-0.8.2.orig/src/zeitgeist-datahub.vala 2012-03-07 09:18:29.000000000 +0100 ++++ zeitgeist-datahub-0.8.2/src/zeitgeist-datahub.vala 2012-04-11 14:01:04.669264362 +0200 +@@ -120,6 +120,9 @@ + providers.prepend (new DesktopLaunchListener (this)); + } + ++ // Ubuntu-specific ++ providers.prepend (new PrePopulator (this)); ++ + foreach (unowned DataProvider prov in providers) + { + bool enabled = true; +Index: zeitgeist-datahub-0.8.2/src/Makefile.in +=================================================================== +--- zeitgeist-datahub-0.8.2.orig/src/Makefile.in 2012-03-20 13:41:13.000000000 +0100 ++++ zeitgeist-datahub-0.8.2/src/Makefile.in 2012-04-11 14:01:04.669264362 +0200 +@@ -38,8 +38,8 @@ + DIST_COMMON = $(srcdir)/Makefile.am $(srcdir)/Makefile.in \ + data-provider.c desktop-launch-listener.c \ + downloads-directory-provider.c kde-recent-document-provider.c \ +- recent-manager-provider.c utils.c zeitgeist-datahub.c \ +- zeitgeist_datahub_vala.stamp ++ pre-populator.c recent-manager-provider.c utils.c \ ++ zeitgeist-datahub.c zeitgeist_datahub_vala.stamp + ACLOCAL_M4 = $(top_srcdir)/aclocal.m4 + am__aclocal_m4_deps = $(top_srcdir)/configure.ac + am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \ +@@ -57,6 +57,7 @@ + zeitgeist_datahub-downloads-directory-provider.$(OBJEXT) \ + zeitgeist_datahub-kde-recent-document-provider.$(OBJEXT) \ + zeitgeist_datahub-recent-manager-provider.$(OBJEXT) \ ++ zeitgeist_datahub-pre-populator.$(OBJEXT) \ + zeitgeist_datahub-utils.$(OBJEXT) \ + zeitgeist_datahub-zeitgeist-datahub.$(OBJEXT) + zeitgeist_datahub_OBJECTS = $(am_zeitgeist_datahub_OBJECTS) +@@ -272,6 +273,7 @@ + downloads-directory-provider.vala \ + kde-recent-document-provider.vala \ + recent-manager-provider.vala \ ++ pre-populator.vala \ + utils.vala \ + zeitgeist-datahub.vala \ + $(optional_zeitgeist_datahub_SOURCES) \ +@@ -371,6 +373,7 @@ + @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/zeitgeist_datahub-desktop-launch-listener.Po@am__quote@ + @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/zeitgeist_datahub-downloads-directory-provider.Po@am__quote@ + @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/zeitgeist_datahub-kde-recent-document-provider.Po@am__quote@ ++@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/zeitgeist_datahub-pre-populator.Po@am__quote@ + @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/zeitgeist_datahub-recent-manager-provider.Po@am__quote@ + @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/zeitgeist_datahub-utils.Po@am__quote@ + @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/zeitgeist_datahub-zeitgeist-datahub.Po@am__quote@ +@@ -459,6 +462,20 @@ + @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ + @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(zeitgeist_datahub_CFLAGS) $(CFLAGS) -c -o zeitgeist_datahub-recent-manager-provider.obj `if test -f 'recent-manager-provider.c'; then $(CYGPATH_W) 'recent-manager-provider.c'; else $(CYGPATH_W) '$(srcdir)/recent-manager-provider.c'; fi` + ++zeitgeist_datahub-pre-populator.o: pre-populator.c ++@am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(zeitgeist_datahub_CFLAGS) $(CFLAGS) -MT zeitgeist_datahub-pre-populator.o -MD -MP -MF $(DEPDIR)/zeitgeist_datahub-pre-populator.Tpo -c -o zeitgeist_datahub-pre-populator.o `test -f 'pre-populator.c' || echo '$(srcdir)/'`pre-populator.c ++@am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/zeitgeist_datahub-pre-populator.Tpo $(DEPDIR)/zeitgeist_datahub-pre-populator.Po ++@AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='pre-populator.c' object='zeitgeist_datahub-pre-populator.o' libtool=no @AMDEPBACKSLASH@ ++@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ ++@am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(zeitgeist_datahub_CFLAGS) $(CFLAGS) -c -o zeitgeist_datahub-pre-populator.o `test -f 'pre-populator.c' || echo '$(srcdir)/'`pre-populator.c ++ ++zeitgeist_datahub-pre-populator.obj: pre-populator.c ++@am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(zeitgeist_datahub_CFLAGS) $(CFLAGS) -MT zeitgeist_datahub-pre-populator.obj -MD -MP -MF $(DEPDIR)/zeitgeist_datahub-pre-populator.Tpo -c -o zeitgeist_datahub-pre-populator.obj `if test -f 'pre-populator.c'; then $(CYGPATH_W) 'pre-populator.c'; else $(CYGPATH_W) '$(srcdir)/pre-populator.c'; fi` ++@am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/zeitgeist_datahub-pre-populator.Tpo $(DEPDIR)/zeitgeist_datahub-pre-populator.Po ++@AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='pre-populator.c' object='zeitgeist_datahub-pre-populator.obj' libtool=no @AMDEPBACKSLASH@ ++@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ ++@am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(zeitgeist_datahub_CFLAGS) $(CFLAGS) -c -o zeitgeist_datahub-pre-populator.obj `if test -f 'pre-populator.c'; then $(CYGPATH_W) 'pre-populator.c'; else $(CYGPATH_W) '$(srcdir)/pre-populator.c'; fi` ++ + zeitgeist_datahub-utils.o: utils.c + @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(zeitgeist_datahub_CFLAGS) $(CFLAGS) -MT zeitgeist_datahub-utils.o -MD -MP -MF $(DEPDIR)/zeitgeist_datahub-utils.Tpo -c -o zeitgeist_datahub-utils.o `test -f 'utils.c' || echo '$(srcdir)/'`utils.c + @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/zeitgeist_datahub-utils.Tpo $(DEPDIR)/zeitgeist_datahub-utils.Po +@@ -511,6 +528,11 @@ + @if test -f $@; then :; else \ + $(MAKE) $(AM_MAKEFLAGS) $(srcdir)/zeitgeist_datahub_vala.stamp; \ + fi ++$(srcdir)/pre-populator.c: $(srcdir)/zeitgeist_datahub_vala.stamp ++ @if test -f $@; then :; else rm -f $(srcdir)/zeitgeist_datahub_vala.stamp; fi ++ @if test -f $@; then :; else \ ++ $(MAKE) $(AM_MAKEFLAGS) $(srcdir)/zeitgeist_datahub_vala.stamp; \ ++ fi + $(srcdir)/utils.c: $(srcdir)/zeitgeist_datahub_vala.stamp + @if test -f $@; then :; else rm -f $(srcdir)/zeitgeist_datahub_vala.stamp; fi + @if test -f $@; then :; else \ +@@ -668,6 +690,7 @@ + -rm -f desktop-launch-listener.c + -rm -f downloads-directory-provider.c + -rm -f kde-recent-document-provider.c ++ -rm -f pre-populator.c + -rm -f recent-manager-provider.c + -rm -f utils.c + -rm -f zeitgeist-datahub.c +Index: zeitgeist-datahub-0.8.2/src/pre-populator.c +=================================================================== +--- /dev/null 1970-01-01 00:00:00.000000000 +0000 ++++ zeitgeist-datahub-0.8.2/src/pre-populator.c 2012-04-11 14:03:35.450012053 +0200 +@@ -0,0 +1,742 @@ ++/* pre-populator.c generated by valac 0.14.2, the Vala compiler ++ * generated from pre-populator.vala, do not modify */ ++ ++/* ++ * Copyright (C) 2012 Canonical Ltd. ++ * ++ * This program is free software: you can redistribute it and/or modify ++ * it under the terms of the GNU Lesser General Public License as published by ++ * the Free Software Foundation, either version 3 of the License, or ++ * (at your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++ * GNU Lesser General Public License for more details. ++ * ++ * You should have received a copy of the GNU Lesser General Public License ++ * along with this program. If not, see . ++ * ++ * Authored by Michal Hruby ++ * ++ */ ++ ++#include ++#include ++#include ++#include ++#include ++#include ++ ++ ++#define TYPE_DATA_PROVIDER (data_provider_get_type ()) ++#define DATA_PROVIDER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_DATA_PROVIDER, DataProvider)) ++#define DATA_PROVIDER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_DATA_PROVIDER, DataProviderClass)) ++#define IS_DATA_PROVIDER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_DATA_PROVIDER)) ++#define IS_DATA_PROVIDER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_DATA_PROVIDER)) ++#define DATA_PROVIDER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_DATA_PROVIDER, DataProviderClass)) ++ ++typedef struct _DataProvider DataProvider; ++typedef struct _DataProviderClass DataProviderClass; ++typedef struct _DataProviderPrivate DataProviderPrivate; ++ ++#define TYPE_DATA_HUB (data_hub_get_type ()) ++#define DATA_HUB(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_DATA_HUB, DataHub)) ++#define DATA_HUB_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_DATA_HUB, DataHubClass)) ++#define IS_DATA_HUB(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_DATA_HUB)) ++#define IS_DATA_HUB_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_DATA_HUB)) ++#define DATA_HUB_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_DATA_HUB, DataHubClass)) ++ ++typedef struct _DataHub DataHub; ++typedef struct _DataHubClass DataHubClass; ++ ++#define TYPE_PRE_POPULATOR (pre_populator_get_type ()) ++#define PRE_POPULATOR(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_PRE_POPULATOR, PrePopulator)) ++#define PRE_POPULATOR_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_PRE_POPULATOR, PrePopulatorClass)) ++#define IS_PRE_POPULATOR(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_PRE_POPULATOR)) ++#define IS_PRE_POPULATOR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_PRE_POPULATOR)) ++#define PRE_POPULATOR_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_PRE_POPULATOR, PrePopulatorClass)) ++ ++typedef struct _PrePopulator PrePopulator; ++typedef struct _PrePopulatorClass PrePopulatorClass; ++typedef struct _PrePopulatorPrivate PrePopulatorPrivate; ++#define _g_free0(var) (var = (g_free (var), NULL)) ++#define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL))) ++#define _g_array_free0(var) ((var == NULL) ? NULL : (var = (g_array_free (var, TRUE), NULL))) ++#define _g_error_free0(var) ((var == NULL) ? NULL : (var = (g_error_free (var), NULL))) ++#define _g_ptr_array_unref0(var) ((var == NULL) ? NULL : (var = (g_ptr_array_unref (var), NULL))) ++typedef struct _PrePopulatorPrepareEventsData PrePopulatorPrepareEventsData; ++ ++struct _DataProvider { ++ GObject parent_instance; ++ DataProviderPrivate * priv; ++}; ++ ++struct _DataProviderClass { ++ GObjectClass parent_class; ++ void (*start) (DataProvider* self); ++ void (*stop) (DataProvider* self); ++ const gchar* (*get_unique_id) (DataProvider* self); ++ void (*set_unique_id) (DataProvider* self, const gchar* value); ++ const gchar* (*get_name) (DataProvider* self); ++ void (*set_name) (DataProvider* self, const gchar* value); ++ const gchar* (*get_description) (DataProvider* self); ++ void (*set_description) (DataProvider* self, const gchar* value); ++ DataHub* (*get_datahub) (DataProvider* self); ++ void (*set_datahub) (DataProvider* self, DataHub* value); ++ gboolean (*get_enabled) (DataProvider* self); ++ void (*set_enabled) (DataProvider* self, gboolean value); ++ gboolean (*get_register) (DataProvider* self); ++ void (*set_register) (DataProvider* self, gboolean value); ++}; ++ ++struct _PrePopulator { ++ DataProvider parent_instance; ++ PrePopulatorPrivate * priv; ++}; ++ ++struct _PrePopulatorClass { ++ DataProviderClass parent_class; ++}; ++ ++struct _PrePopulatorPrivate { ++ gchar* _unique_id; ++ gchar* _name; ++ gchar* _description; ++ DataHub* _datahub; ++ gboolean _enabled; ++ gboolean _register; ++}; ++ ++struct _PrePopulatorPrepareEventsData { ++ int _state_; ++ GObject* _source_object_; ++ GAsyncResult* _res_; ++ GSimpleAsyncResult* _async_result; ++ PrePopulator* self; ++ GPtrArray* _tmp0_; ++ GPtrArray* arr; ++ gint64 _tmp1_; ++ gint64 ts; ++ GPtrArray* _tmp2_; ++ gint64 _tmp3_; ++ gint64 _tmp4_; ++ ZeitgeistEvent* _tmp5_; ++ GPtrArray* _tmp6_; ++ gint64 _tmp7_; ++ gint64 _tmp8_; ++ ZeitgeistEvent* _tmp9_; ++ GPtrArray* _tmp10_; ++ gint64 _tmp11_; ++ gint64 _tmp12_; ++ ZeitgeistEvent* _tmp13_; ++ GPtrArray* _tmp14_; ++ gint64 _tmp15_; ++ gint64 _tmp16_; ++ ZeitgeistEvent* _tmp17_; ++ GPtrArray* _tmp18_; ++ gint64 _tmp19_; ++ gint64 _tmp20_; ++ ZeitgeistEvent* _tmp21_; ++ GPtrArray* _tmp22_; ++ gint64 _tmp23_; ++ gint64 _tmp24_; ++ ZeitgeistEvent* _tmp25_; ++ ZeitgeistLog* _tmp26_; ++ ZeitgeistLog* log; ++ ZeitgeistLog* _tmp27_; ++ ZeitgeistTimeRange* _tmp28_; ++ ZeitgeistTimeRange* _tmp29_; ++ GPtrArray* _tmp30_; ++ GArray* _tmp31_; ++ GArray* _tmp32_; ++ GArray* ids; ++ GArray* _tmp33_; ++ guint _tmp34_; ++ GPtrArray* _tmp35_; ++ ZeitgeistDataSourceRegistry* _tmp36_; ++ ZeitgeistDataSourceRegistry* registry; ++ ZeitgeistDataSourceRegistry* _tmp37_; ++ const gchar* _tmp38_; ++ const gchar* _tmp39_; ++ GError* err; ++ GError* _tmp40_; ++ const gchar* _tmp41_; ++ GError * _inner_error_; ++}; ++ ++ ++static gpointer pre_populator_parent_class = NULL; ++ ++GType data_provider_get_type (void) G_GNUC_CONST; ++GType data_hub_get_type (void) G_GNUC_CONST; ++GType pre_populator_get_type (void) G_GNUC_CONST; ++#define PRE_POPULATOR_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), TYPE_PRE_POPULATOR, PrePopulatorPrivate)) ++enum { ++ PRE_POPULATOR_DUMMY_PROPERTY, ++ PRE_POPULATOR_UNIQUE_ID, ++ PRE_POPULATOR_NAME, ++ PRE_POPULATOR_DESCRIPTION, ++ PRE_POPULATOR_DATAHUB, ++ PRE_POPULATOR_ENABLED, ++ PRE_POPULATOR_REGISTER ++}; ++PrePopulator* pre_populator_new (DataHub* datahub); ++PrePopulator* pre_populator_construct (GType object_type, DataHub* datahub); ++static void pre_populator_real_start (DataProvider* base); ++static void pre_populator_prepare_events (PrePopulator* self, GAsyncReadyCallback _callback_, gpointer _user_data_); ++static void pre_populator_prepare_events_finish (PrePopulator* self, GAsyncResult* _res_); ++static ZeitgeistEvent* pre_populator_event_for_desktop_file (PrePopulator* self, const gchar* desktop_file, gint64 timestamp); ++static void pre_populator_prepare_events_data_free (gpointer _data); ++static gboolean pre_populator_prepare_events_co (PrePopulatorPrepareEventsData* _data_); ++static void _g_object_unref0_ (gpointer var); ++static void pre_populator_prepare_events_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_); ++static gboolean _pre_populator_prepare_events_co_gsource_func (gpointer self); ++const gchar* data_provider_get_unique_id (DataProvider* self); ++static void pre_populator_real_stop (DataProvider* base); ++static GObject * pre_populator_constructor (GType type, guint n_construct_properties, GObjectConstructParam * construct_properties); ++static void pre_populator_finalize (GObject* obj); ++const gchar* data_provider_get_name (DataProvider* self); ++const gchar* data_provider_get_description (DataProvider* self); ++DataHub* data_provider_get_datahub (DataProvider* self); ++gboolean data_provider_get_enabled (DataProvider* self); ++gboolean data_provider_get_register (DataProvider* self); ++static void _vala_pre_populator_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec); ++void data_provider_set_unique_id (DataProvider* self, const gchar* value); ++void data_provider_set_name (DataProvider* self, const gchar* value); ++void data_provider_set_description (DataProvider* self, const gchar* value); ++void data_provider_set_datahub (DataProvider* self, DataHub* value); ++void data_provider_set_enabled (DataProvider* self, gboolean value); ++void data_provider_set_register (DataProvider* self, gboolean value); ++static void _vala_pre_populator_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec); ++ ++ ++PrePopulator* pre_populator_construct (GType object_type, DataHub* datahub) { ++ PrePopulator * self = NULL; ++ DataHub* _tmp0_; ++ g_return_val_if_fail (datahub != NULL, NULL); ++ _tmp0_ = datahub; ++ self = (PrePopulator*) g_object_new (object_type, "unique-id", "com.canonical,datahub,pre-populator", "name", "Pre-populate the log", "description", "Pushes a couple of events so Ubuntu Dash home is not empty when doing " \ ++"new install", "datahub", _tmp0_, NULL); ++ return self; ++} ++ ++ ++PrePopulator* pre_populator_new (DataHub* datahub) { ++ return pre_populator_construct (TYPE_PRE_POPULATOR, datahub); ++} ++ ++ ++static void pre_populator_real_start (DataProvider* base) { ++ PrePopulator * self; ++ self = (PrePopulator*) base; ++ pre_populator_prepare_events (self, NULL, NULL); ++} ++ ++ ++static ZeitgeistEvent* pre_populator_event_for_desktop_file (PrePopulator* self, const gchar* desktop_file, gint64 timestamp) { ++ ZeitgeistEvent* result = NULL; ++ ZeitgeistEvent* _tmp0_; ++ ZeitgeistEvent* _tmp1_; ++ ZeitgeistEvent* event; ++ gint64 _tmp2_; ++ ZeitgeistSubject* _tmp3_; ++ ZeitgeistSubject* _tmp4_; ++ ZeitgeistSubject* subject; ++ const gchar* _tmp5_; ++ gchar* _tmp6_ = NULL; ++ gchar* _tmp7_; ++ g_return_val_if_fail (self != NULL, NULL); ++ g_return_val_if_fail (desktop_file != NULL, NULL); ++ _tmp0_ = zeitgeist_event_new (); ++ _tmp1_ = g_object_ref_sink (_tmp0_); ++ event = _tmp1_; ++ _tmp2_ = timestamp; ++ zeitgeist_event_set_timestamp (event, _tmp2_); ++ _tmp3_ = zeitgeist_subject_new (); ++ _tmp4_ = g_object_ref_sink (_tmp3_); ++ subject = _tmp4_; ++ zeitgeist_event_set_actor (event, "application://zeitgeist-datahub.desktop"); ++ zeitgeist_event_set_interpretation (event, ZEITGEIST_ZG_ACCESS_EVENT); ++ zeitgeist_event_set_manifestation (event, ZEITGEIST_ZG_USER_ACTIVITY); ++ zeitgeist_event_add_subject (event, subject); ++ _tmp5_ = desktop_file; ++ _tmp6_ = g_strdup_printf ("application://%s", _tmp5_); ++ _tmp7_ = _tmp6_; ++ zeitgeist_subject_set_uri (subject, _tmp7_); ++ _g_free0 (_tmp7_); ++ zeitgeist_subject_set_interpretation (subject, ZEITGEIST_NFO_SOFTWARE); ++ zeitgeist_subject_set_manifestation (subject, ZEITGEIST_NFO_SOFTWARE_ITEM); ++ zeitgeist_subject_set_mimetype (subject, "application/x-desktop"); ++ result = event; ++ _g_object_unref0 (subject); ++ return result; ++} ++ ++ ++static void pre_populator_prepare_events_data_free (gpointer _data) { ++ PrePopulatorPrepareEventsData* _data_; ++ _data_ = _data; ++ _g_object_unref0 (_data_->self); ++ g_slice_free (PrePopulatorPrepareEventsData, _data_); ++} ++ ++ ++static gpointer _g_object_ref0 (gpointer self) { ++ return self ? g_object_ref (self) : NULL; ++} ++ ++ ++static void pre_populator_prepare_events (PrePopulator* self, GAsyncReadyCallback _callback_, gpointer _user_data_) { ++ PrePopulatorPrepareEventsData* _data_; ++ PrePopulator* _tmp0_; ++ _data_ = g_slice_new0 (PrePopulatorPrepareEventsData); ++ _data_->_async_result = g_simple_async_result_new (G_OBJECT (self), _callback_, _user_data_, pre_populator_prepare_events); ++ g_simple_async_result_set_op_res_gpointer (_data_->_async_result, _data_, pre_populator_prepare_events_data_free); ++ _tmp0_ = _g_object_ref0 (self); ++ _data_->self = _tmp0_; ++ pre_populator_prepare_events_co (_data_); ++} ++ ++ ++static void pre_populator_prepare_events_finish (PrePopulator* self, GAsyncResult* _res_) { ++ PrePopulatorPrepareEventsData* _data_; ++ _data_ = g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (_res_)); ++} ++ ++ ++static void _g_object_unref0_ (gpointer var) { ++ (var == NULL) ? NULL : (var = (g_object_unref (var), NULL)); ++} ++ ++ ++static void pre_populator_prepare_events_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_) { ++ PrePopulatorPrepareEventsData* _data_; ++ _data_ = _user_data_; ++ _data_->_source_object_ = source_object; ++ _data_->_res_ = _res_; ++ pre_populator_prepare_events_co (_data_); ++} ++ ++ ++static gboolean _pre_populator_prepare_events_co_gsource_func (gpointer self) { ++ gboolean result; ++ result = pre_populator_prepare_events_co (self); ++ return result; ++} ++ ++ ++static gboolean pre_populator_prepare_events_co (PrePopulatorPrepareEventsData* _data_) { ++ switch (_data_->_state_) { ++ case 0: ++ goto _state_0; ++ case 1: ++ goto _state_1; ++ case 2: ++ goto _state_2; ++ case 3: ++ goto _state_3; ++ default: ++ g_assert_not_reached (); ++ } ++ _state_0: ++ _data_->_tmp0_ = g_ptr_array_new_with_free_func (_g_object_unref0_); ++ _data_->arr = _data_->_tmp0_; ++ _data_->_tmp1_ = 0LL; ++ _data_->_tmp1_ = zeitgeist_timestamp_for_now (); ++ _data_->ts = _data_->_tmp1_; ++ _data_->_tmp2_ = _data_->arr; ++ _data_->_tmp3_ = _data_->ts; ++ _data_->ts = _data_->_tmp3_ + 1; ++ _data_->_tmp4_ = _data_->ts; ++ _data_->_tmp5_ = NULL; ++ _data_->_tmp5_ = pre_populator_event_for_desktop_file (_data_->self, "rhythmbox.desktop", _data_->_tmp4_); ++ g_ptr_array_add (_data_->_tmp2_, _data_->_tmp5_); ++ _data_->_tmp6_ = _data_->arr; ++ _data_->_tmp7_ = _data_->ts; ++ _data_->ts = _data_->_tmp7_ + 1; ++ _data_->_tmp8_ = _data_->ts; ++ _data_->_tmp9_ = NULL; ++ _data_->_tmp9_ = pre_populator_event_for_desktop_file (_data_->self, "gcalctool.desktop", _data_->_tmp8_); ++ g_ptr_array_add (_data_->_tmp6_, _data_->_tmp9_); ++ _data_->_tmp10_ = _data_->arr; ++ _data_->_tmp11_ = _data_->ts; ++ _data_->ts = _data_->_tmp11_ + 1; ++ _data_->_tmp12_ = _data_->ts; ++ _data_->_tmp13_ = NULL; ++ _data_->_tmp13_ = pre_populator_event_for_desktop_file (_data_->self, "gedit.desktop", _data_->_tmp12_); ++ g_ptr_array_add (_data_->_tmp10_, _data_->_tmp13_); ++ _data_->_tmp14_ = _data_->arr; ++ _data_->_tmp15_ = _data_->ts; ++ _data_->ts = _data_->_tmp15_ + 1; ++ _data_->_tmp16_ = _data_->ts; ++ _data_->_tmp17_ = NULL; ++ _data_->_tmp17_ = pre_populator_event_for_desktop_file (_data_->self, "totem.desktop", _data_->_tmp16_); ++ g_ptr_array_add (_data_->_tmp14_, _data_->_tmp17_); ++ _data_->_tmp18_ = _data_->arr; ++ _data_->_tmp19_ = _data_->ts; ++ _data_->ts = _data_->_tmp19_ + 1; ++ _data_->_tmp20_ = _data_->ts; ++ _data_->_tmp21_ = NULL; ++ _data_->_tmp21_ = pre_populator_event_for_desktop_file (_data_->self, "thunderbird.desktop", _data_->_tmp20_); ++ g_ptr_array_add (_data_->_tmp18_, _data_->_tmp21_); ++ _data_->_tmp22_ = _data_->arr; ++ _data_->_tmp23_ = _data_->ts; ++ _data_->ts = _data_->_tmp23_ + 1; ++ _data_->_tmp24_ = _data_->ts; ++ _data_->_tmp25_ = NULL; ++ _data_->_tmp25_ = pre_populator_event_for_desktop_file (_data_->self, "yelp.desktop", _data_->_tmp24_); ++ g_ptr_array_add (_data_->_tmp22_, _data_->_tmp25_); ++ { ++ _data_->_tmp26_ = zeitgeist_log_new (); ++ _data_->log = _data_->_tmp26_; ++ _data_->_tmp27_ = _data_->log; ++ _data_->_tmp28_ = zeitgeist_time_range_new_anytime (); ++ _data_->_tmp29_ = g_object_ref_sink (_data_->_tmp28_); ++ _data_->_tmp30_ = g_ptr_array_new (); ++ _data_->_state_ = 1; ++ zeitgeist_log_find_event_ids (_data_->_tmp27_, _data_->_tmp29_, _data_->_tmp30_, ZEITGEIST_STORAGE_STATE_ANY, (guint32) 1, ZEITGEIST_RESULT_TYPE_MOST_RECENT_EVENTS, NULL, pre_populator_prepare_events_ready, _data_); ++ return FALSE; ++ _state_1: ++ _data_->_tmp31_ = NULL; ++ _data_->_tmp31_ = zeitgeist_log_find_event_ids_finish (_data_->_tmp27_, _data_->_res_, &_data_->_inner_error_); ++ _data_->_tmp32_ = _data_->_tmp31_; ++ _g_object_unref0 (_data_->_tmp29_); ++ _data_->ids = _data_->_tmp32_; ++ if (_data_->_inner_error_ != NULL) { ++ _g_object_unref0 (_data_->log); ++ goto __catch4_g_error; ++ } ++ _data_->_tmp33_ = _data_->ids; ++ _data_->_tmp34_ = _data_->_tmp33_->len; ++ if (_data_->_tmp34_ == ((guint) 0)) { ++ _data_->_tmp35_ = _data_->arr; ++ g_signal_emit_by_name ((DataProvider*) _data_->self, "items-available", _data_->_tmp35_); ++ g_timeout_add_seconds_full (G_PRIORITY_DEFAULT, (guint) 5, _pre_populator_prepare_events_co_gsource_func, _data_, NULL); ++ _data_->_state_ = 2; ++ return FALSE; ++ _state_2: ++ ; ++ } ++ _data_->_tmp36_ = zeitgeist_data_source_registry_new (); ++ _data_->registry = _data_->_tmp36_; ++ _data_->_tmp37_ = _data_->registry; ++ _data_->_tmp38_ = data_provider_get_unique_id ((DataProvider*) _data_->self); ++ _data_->_tmp39_ = _data_->_tmp38_; ++ _data_->_state_ = 3; ++ zeitgeist_data_source_registry_set_data_source_enabled (_data_->_tmp37_, _data_->_tmp39_, FALSE, NULL, pre_populator_prepare_events_ready, _data_); ++ return FALSE; ++ _state_3: ++ zeitgeist_data_source_registry_set_data_source_enabled_finish (_data_->_tmp37_, _data_->_res_, &_data_->_inner_error_); ++ if (_data_->_inner_error_ != NULL) { ++ _g_object_unref0 (_data_->registry); ++ _g_array_free0 (_data_->ids); ++ _g_object_unref0 (_data_->log); ++ goto __catch4_g_error; ++ } ++ _g_object_unref0 (_data_->registry); ++ _g_array_free0 (_data_->ids); ++ _g_object_unref0 (_data_->log); ++ } ++ goto __finally4; ++ __catch4_g_error: ++ { ++ _data_->err = _data_->_inner_error_; ++ _data_->_inner_error_ = NULL; ++ _data_->_tmp40_ = _data_->err; ++ _data_->_tmp41_ = _data_->_tmp40_->message; ++ g_warning ("pre-populator.vala:109: %s", _data_->_tmp41_); ++ _g_error_free0 (_data_->err); ++ } ++ __finally4: ++ if (_data_->_inner_error_ != NULL) { ++ _g_ptr_array_unref0 (_data_->arr); ++ g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code); ++ g_clear_error (&_data_->_inner_error_); ++ return FALSE; ++ } ++ _g_ptr_array_unref0 (_data_->arr); ++ if (_data_->_state_ == 0) { ++ g_simple_async_result_complete_in_idle (_data_->_async_result); ++ } else { ++ g_simple_async_result_complete (_data_->_async_result); ++ } ++ g_object_unref (_data_->_async_result); ++ return FALSE; ++} ++ ++ ++static void pre_populator_real_stop (DataProvider* base) { ++ PrePopulator * self; ++ self = (PrePopulator*) base; ++} ++ ++ ++static const gchar* pre_populator_real_get_unique_id (DataProvider* base) { ++ const gchar* result; ++ PrePopulator* self; ++ const gchar* _tmp0_; ++ self = (PrePopulator*) base; ++ _tmp0_ = self->priv->_unique_id; ++ result = _tmp0_; ++ return result; ++} ++ ++ ++static void pre_populator_real_set_unique_id (DataProvider* base, const gchar* value) { ++ PrePopulator* self; ++ const gchar* _tmp0_; ++ gchar* _tmp1_; ++ self = (PrePopulator*) base; ++ _tmp0_ = value; ++ _tmp1_ = g_strdup (_tmp0_); ++ _g_free0 (self->priv->_unique_id); ++ self->priv->_unique_id = _tmp1_; ++ g_object_notify ((GObject *) self, "unique-id"); ++} ++ ++ ++static const gchar* pre_populator_real_get_name (DataProvider* base) { ++ const gchar* result; ++ PrePopulator* self; ++ const gchar* _tmp0_; ++ self = (PrePopulator*) base; ++ _tmp0_ = self->priv->_name; ++ result = _tmp0_; ++ return result; ++} ++ ++ ++static void pre_populator_real_set_name (DataProvider* base, const gchar* value) { ++ PrePopulator* self; ++ const gchar* _tmp0_; ++ gchar* _tmp1_; ++ self = (PrePopulator*) base; ++ _tmp0_ = value; ++ _tmp1_ = g_strdup (_tmp0_); ++ _g_free0 (self->priv->_name); ++ self->priv->_name = _tmp1_; ++ g_object_notify ((GObject *) self, "name"); ++} ++ ++ ++static const gchar* pre_populator_real_get_description (DataProvider* base) { ++ const gchar* result; ++ PrePopulator* self; ++ const gchar* _tmp0_; ++ self = (PrePopulator*) base; ++ _tmp0_ = self->priv->_description; ++ result = _tmp0_; ++ return result; ++} ++ ++ ++static void pre_populator_real_set_description (DataProvider* base, const gchar* value) { ++ PrePopulator* self; ++ const gchar* _tmp0_; ++ gchar* _tmp1_; ++ self = (PrePopulator*) base; ++ _tmp0_ = value; ++ _tmp1_ = g_strdup (_tmp0_); ++ _g_free0 (self->priv->_description); ++ self->priv->_description = _tmp1_; ++ g_object_notify ((GObject *) self, "description"); ++} ++ ++ ++static DataHub* pre_populator_real_get_datahub (DataProvider* base) { ++ DataHub* result; ++ PrePopulator* self; ++ DataHub* _tmp0_; ++ self = (PrePopulator*) base; ++ _tmp0_ = self->priv->_datahub; ++ result = _tmp0_; ++ return result; ++} ++ ++ ++static void pre_populator_real_set_datahub (DataProvider* base, DataHub* value) { ++ PrePopulator* self; ++ DataHub* _tmp0_; ++ DataHub* _tmp1_; ++ self = (PrePopulator*) base; ++ _tmp0_ = value; ++ _tmp1_ = _g_object_ref0 (_tmp0_); ++ _g_object_unref0 (self->priv->_datahub); ++ self->priv->_datahub = _tmp1_; ++ g_object_notify ((GObject *) self, "datahub"); ++} ++ ++ ++static gboolean pre_populator_real_get_enabled (DataProvider* base) { ++ gboolean result; ++ PrePopulator* self; ++ gboolean _tmp0_; ++ self = (PrePopulator*) base; ++ _tmp0_ = self->priv->_enabled; ++ result = _tmp0_; ++ return result; ++} ++ ++ ++static void pre_populator_real_set_enabled (DataProvider* base, gboolean value) { ++ PrePopulator* self; ++ gboolean _tmp0_; ++ self = (PrePopulator*) base; ++ _tmp0_ = value; ++ self->priv->_enabled = _tmp0_; ++ g_object_notify ((GObject *) self, "enabled"); ++} ++ ++ ++static gboolean pre_populator_real_get_register (DataProvider* base) { ++ gboolean result; ++ PrePopulator* self; ++ gboolean _tmp0_; ++ self = (PrePopulator*) base; ++ _tmp0_ = self->priv->_register; ++ result = _tmp0_; ++ return result; ++} ++ ++ ++static void pre_populator_real_set_register (DataProvider* base, gboolean value) { ++ PrePopulator* self; ++ gboolean _tmp0_; ++ self = (PrePopulator*) base; ++ _tmp0_ = value; ++ self->priv->_register = _tmp0_; ++ g_object_notify ((GObject *) self, "register"); ++} ++ ++ ++static GObject * pre_populator_constructor (GType type, guint n_construct_properties, GObjectConstructParam * construct_properties) { ++ GObject * obj; ++ GObjectClass * parent_class; ++ PrePopulator * self; ++ parent_class = G_OBJECT_CLASS (pre_populator_parent_class); ++ obj = parent_class->constructor (type, n_construct_properties, construct_properties); ++ self = PRE_POPULATOR (obj); ++ return obj; ++} ++ ++ ++static void pre_populator_class_init (PrePopulatorClass * klass) { ++ pre_populator_parent_class = g_type_class_peek_parent (klass); ++ g_type_class_add_private (klass, sizeof (PrePopulatorPrivate)); ++ DATA_PROVIDER_CLASS (klass)->start = pre_populator_real_start; ++ DATA_PROVIDER_CLASS (klass)->stop = pre_populator_real_stop; ++ DATA_PROVIDER_CLASS (klass)->get_unique_id = pre_populator_real_get_unique_id; ++ DATA_PROVIDER_CLASS (klass)->set_unique_id = pre_populator_real_set_unique_id; ++ DATA_PROVIDER_CLASS (klass)->get_name = pre_populator_real_get_name; ++ DATA_PROVIDER_CLASS (klass)->set_name = pre_populator_real_set_name; ++ DATA_PROVIDER_CLASS (klass)->get_description = pre_populator_real_get_description; ++ DATA_PROVIDER_CLASS (klass)->set_description = pre_populator_real_set_description; ++ DATA_PROVIDER_CLASS (klass)->get_datahub = pre_populator_real_get_datahub; ++ DATA_PROVIDER_CLASS (klass)->set_datahub = pre_populator_real_set_datahub; ++ DATA_PROVIDER_CLASS (klass)->get_enabled = pre_populator_real_get_enabled; ++ DATA_PROVIDER_CLASS (klass)->set_enabled = pre_populator_real_set_enabled; ++ DATA_PROVIDER_CLASS (klass)->get_register = pre_populator_real_get_register; ++ DATA_PROVIDER_CLASS (klass)->set_register = pre_populator_real_set_register; ++ G_OBJECT_CLASS (klass)->get_property = _vala_pre_populator_get_property; ++ G_OBJECT_CLASS (klass)->set_property = _vala_pre_populator_set_property; ++ G_OBJECT_CLASS (klass)->constructor = pre_populator_constructor; ++ G_OBJECT_CLASS (klass)->finalize = pre_populator_finalize; ++ g_object_class_install_property (G_OBJECT_CLASS (klass), PRE_POPULATOR_UNIQUE_ID, g_param_spec_string ("unique-id", "unique-id", "unique-id", NULL, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE | G_PARAM_WRITABLE | G_PARAM_CONSTRUCT)); ++ g_object_class_install_property (G_OBJECT_CLASS (klass), PRE_POPULATOR_NAME, g_param_spec_string ("name", "name", "name", NULL, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE | G_PARAM_WRITABLE | G_PARAM_CONSTRUCT)); ++ g_object_class_install_property (G_OBJECT_CLASS (klass), PRE_POPULATOR_DESCRIPTION, g_param_spec_string ("description", "description", "description", NULL, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE | G_PARAM_WRITABLE | G_PARAM_CONSTRUCT)); ++ g_object_class_install_property (G_OBJECT_CLASS (klass), PRE_POPULATOR_DATAHUB, g_param_spec_object ("datahub", "datahub", "datahub", TYPE_DATA_HUB, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE | G_PARAM_WRITABLE | G_PARAM_CONSTRUCT)); ++ g_object_class_install_property (G_OBJECT_CLASS (klass), PRE_POPULATOR_ENABLED, g_param_spec_boolean ("enabled", "enabled", "enabled", TRUE, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE | G_PARAM_WRITABLE)); ++ g_object_class_install_property (G_OBJECT_CLASS (klass), PRE_POPULATOR_REGISTER, g_param_spec_boolean ("register", "register", "register", TRUE, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE | G_PARAM_WRITABLE | G_PARAM_CONSTRUCT)); ++} ++ ++ ++static void pre_populator_instance_init (PrePopulator * self) { ++ self->priv = PRE_POPULATOR_GET_PRIVATE (self); ++ self->priv->_enabled = TRUE; ++ self->priv->_register = TRUE; ++} ++ ++ ++static void pre_populator_finalize (GObject* obj) { ++ PrePopulator * self; ++ self = PRE_POPULATOR (obj); ++ _g_free0 (self->priv->_unique_id); ++ _g_free0 (self->priv->_name); ++ _g_free0 (self->priv->_description); ++ _g_object_unref0 (self->priv->_datahub); ++ G_OBJECT_CLASS (pre_populator_parent_class)->finalize (obj); ++} ++ ++ ++GType pre_populator_get_type (void) { ++ static volatile gsize pre_populator_type_id__volatile = 0; ++ if (g_once_init_enter (&pre_populator_type_id__volatile)) { ++ static const GTypeInfo g_define_type_info = { sizeof (PrePopulatorClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) pre_populator_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (PrePopulator), 0, (GInstanceInitFunc) pre_populator_instance_init, NULL }; ++ GType pre_populator_type_id; ++ pre_populator_type_id = g_type_register_static (TYPE_DATA_PROVIDER, "PrePopulator", &g_define_type_info, 0); ++ g_once_init_leave (&pre_populator_type_id__volatile, pre_populator_type_id); ++ } ++ return pre_populator_type_id__volatile; ++} ++ ++ ++static void _vala_pre_populator_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec) { ++ PrePopulator * self; ++ self = PRE_POPULATOR (object); ++ switch (property_id) { ++ case PRE_POPULATOR_UNIQUE_ID: ++ g_value_set_string (value, data_provider_get_unique_id ((DataProvider*) self)); ++ break; ++ case PRE_POPULATOR_NAME: ++ g_value_set_string (value, data_provider_get_name ((DataProvider*) self)); ++ break; ++ case PRE_POPULATOR_DESCRIPTION: ++ g_value_set_string (value, data_provider_get_description ((DataProvider*) self)); ++ break; ++ case PRE_POPULATOR_DATAHUB: ++ g_value_set_object (value, data_provider_get_datahub ((DataProvider*) self)); ++ break; ++ case PRE_POPULATOR_ENABLED: ++ g_value_set_boolean (value, data_provider_get_enabled ((DataProvider*) self)); ++ break; ++ case PRE_POPULATOR_REGISTER: ++ g_value_set_boolean (value, data_provider_get_register ((DataProvider*) self)); ++ break; ++ default: ++ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); ++ break; ++ } ++} ++ ++ ++static void _vala_pre_populator_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec) { ++ PrePopulator * self; ++ self = PRE_POPULATOR (object); ++ switch (property_id) { ++ case PRE_POPULATOR_UNIQUE_ID: ++ data_provider_set_unique_id ((DataProvider*) self, g_value_get_string (value)); ++ break; ++ case PRE_POPULATOR_NAME: ++ data_provider_set_name ((DataProvider*) self, g_value_get_string (value)); ++ break; ++ case PRE_POPULATOR_DESCRIPTION: ++ data_provider_set_description ((DataProvider*) self, g_value_get_string (value)); ++ break; ++ case PRE_POPULATOR_DATAHUB: ++ data_provider_set_datahub ((DataProvider*) self, g_value_get_object (value)); ++ break; ++ case PRE_POPULATOR_ENABLED: ++ data_provider_set_enabled ((DataProvider*) self, g_value_get_boolean (value)); ++ break; ++ case PRE_POPULATOR_REGISTER: ++ data_provider_set_register ((DataProvider*) self, g_value_get_boolean (value)); ++ break; ++ default: ++ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); ++ break; ++ } ++} ++ ++ ++ +Index: zeitgeist-datahub-0.8.2/src/glib-extra.vapi +=================================================================== +--- /dev/null 1970-01-01 00:00:00.000000000 +0000 ++++ zeitgeist-datahub-0.8.2/src/glib-extra.vapi 2012-04-11 14:01:04.669264362 +0200 +@@ -0,0 +1,5 @@ ++[CCode (cprefix = "G", lower_case_cprefix = "g_")] ++namespace GLibExtra { ++ [CCode (cname = "GLIB_CHECK_VERSION")] ++ public static bool check_version (uint major, uint minor, uint micro); ++} +Index: zeitgeist-datahub-0.8.2/src/zeitgeist-datahub.c +=================================================================== +--- zeitgeist-datahub-0.8.2.orig/src/zeitgeist-datahub.c 2012-03-07 12:13:49.000000000 +0100 ++++ zeitgeist-datahub-0.8.2/src/zeitgeist-datahub.c 2012-04-11 14:03:29.009980110 +0200 +@@ -110,6 +110,16 @@ + + typedef struct _DesktopLaunchListener DesktopLaunchListener; + typedef struct _DesktopLaunchListenerClass DesktopLaunchListenerClass; ++ ++#define TYPE_PRE_POPULATOR (pre_populator_get_type ()) ++#define PRE_POPULATOR(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_PRE_POPULATOR, PrePopulator)) ++#define PRE_POPULATOR_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_PRE_POPULATOR, PrePopulatorClass)) ++#define IS_PRE_POPULATOR(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_PRE_POPULATOR)) ++#define IS_PRE_POPULATOR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_PRE_POPULATOR)) ++#define PRE_POPULATOR_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_PRE_POPULATOR, PrePopulatorClass)) ++ ++typedef struct _PrePopulator PrePopulator; ++typedef struct _PrePopulatorClass PrePopulatorClass; + typedef struct _DataHubStartDataProvidersData DataHubStartDataProvidersData; + typedef struct _Block1Data Block1Data; + #define _g_array_free0(var) ((var == NULL) ? NULL : (var = (g_array_free (var, TRUE), NULL))) +@@ -171,53 +181,54 @@ + DownloadsDirectoryMonitor* _tmp19_; + gboolean _tmp20_; + DesktopLaunchListener* _tmp21_; +- GList* _tmp22_; ++ PrePopulator* _tmp22_; ++ GList* _tmp23_; + GList* prov_collection; + GList* prov_it; + DataProvider* prov; + gboolean enabled; + gint64 timestamp; +- GList* _tmp23_; ++ GList* _tmp24_; + GList* src_collection; + GList* src_it; +- ZeitgeistDataSource* _tmp24_; +- ZeitgeistDataSource* src; + ZeitgeistDataSource* _tmp25_; +- const gchar* _tmp26_; +- DataProvider* _tmp27_; +- const gchar* _tmp28_; ++ ZeitgeistDataSource* src; ++ ZeitgeistDataSource* _tmp26_; ++ const gchar* _tmp27_; ++ DataProvider* _tmp28_; + const gchar* _tmp29_; +- ZeitgeistDataSource* _tmp30_; +- gint64 _tmp31_; +- DataProvider* _tmp32_; +- gboolean _tmp33_; ++ const gchar* _tmp30_; ++ ZeitgeistDataSource* _tmp31_; ++ gint64 _tmp32_; ++ DataProvider* _tmp33_; + gboolean _tmp34_; +- DataProvider* _tmp35_; +- const gchar* _tmp36_; ++ gboolean _tmp35_; ++ DataProvider* _tmp36_; + const gchar* _tmp37_; +- DataProvider* _tmp38_; +- const gchar* _tmp39_; ++ const gchar* _tmp38_; ++ DataProvider* _tmp39_; + const gchar* _tmp40_; +- DataProvider* _tmp41_; +- const gchar* _tmp42_; ++ const gchar* _tmp41_; ++ DataProvider* _tmp42_; + const gchar* _tmp43_; +- GPtrArray* _tmp44_; +- ZeitgeistDataSource* _tmp45_; ++ const gchar* _tmp44_; ++ GPtrArray* _tmp45_; + ZeitgeistDataSource* _tmp46_; ++ ZeitgeistDataSource* _tmp47_; + ZeitgeistDataSource* ds; +- ZeitgeistDataSourceRegistry* _tmp47_; +- ZeitgeistDataSource* _tmp48_; ++ ZeitgeistDataSourceRegistry* _tmp48_; + ZeitgeistDataSource* _tmp49_; +- gboolean _tmp50_; ++ ZeitgeistDataSource* _tmp50_; + gboolean _tmp51_; ++ gboolean _tmp52_; + GError* reg_err; +- GError* _tmp52_; +- const gchar* _tmp53_; +- DataProvider* _tmp54_; +- gboolean _tmp55_; +- DataProvider* _tmp56_; +- gint64 _tmp57_; +- DataProvider* _tmp58_; ++ GError* _tmp53_; ++ const gchar* _tmp54_; ++ DataProvider* _tmp55_; ++ gboolean _tmp56_; ++ DataProvider* _tmp57_; ++ gint64 _tmp58_; ++ DataProvider* _tmp59_; + GError * _inner_error_; + }; + +@@ -317,6 +328,9 @@ + DesktopLaunchListener* desktop_launch_listener_new (DataHub* datahub); + DesktopLaunchListener* desktop_launch_listener_construct (GType object_type, DataHub* datahub); + GType desktop_launch_listener_get_type (void) G_GNUC_CONST; ++PrePopulator* pre_populator_new (DataHub* datahub); ++PrePopulator* pre_populator_construct (GType object_type, DataHub* datahub); ++GType pre_populator_get_type (void) G_GNUC_CONST; + const gchar* data_provider_get_unique_id (DataProvider* self); + gboolean data_provider_get_register (DataProvider* self); + const gchar* data_provider_get_name (DataProvider* self); +@@ -722,7 +736,7 @@ + _data_->_tmp2_ = zeitgeist_data_source_registry_get_data_sources_finish (_data_->_tmp1_, _data_->_res_, &_data_->_inner_error_); + _data_->sources = _data_->_tmp2_; + if (_data_->_inner_error_ != NULL) { +- goto __catch7_g_error; ++ goto __catch8_g_error; + } + { + _data_->i = (guint) 0; +@@ -752,8 +766,8 @@ + } + _g_ptr_array_free0 (_data_->sources); + } +- goto __finally7; +- __catch7_g_error: ++ goto __finally8; ++ __catch8_g_error: + { + _data_->err = _data_->_inner_error_; + _data_->_inner_error_ = NULL; +@@ -762,7 +776,7 @@ + g_warning ("zeitgeist-datahub.vala:103: %s", _data_->_tmp14_); + _g_error_free0 (_data_->err); + } +- __finally7: ++ __finally8: + if (_data_->_inner_error_ != NULL) { + g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code); + g_clear_error (&_data_->_inner_error_); +@@ -794,34 +808,36 @@ + _data_->_tmp21_ = desktop_launch_listener_new (_data_->self); + _data_->self->priv->providers = g_list_prepend (_data_->self->priv->providers, (DataProvider*) _data_->_tmp21_); + } +- _data_->_tmp22_ = _data_->self->priv->providers; ++ _data_->_tmp22_ = pre_populator_new (_data_->self); ++ _data_->self->priv->providers = g_list_prepend (_data_->self->priv->providers, (DataProvider*) _data_->_tmp22_); ++ _data_->_tmp23_ = _data_->self->priv->providers; + { +- _data_->prov_collection = _data_->_tmp22_; ++ _data_->prov_collection = _data_->_tmp23_; + _data_->prov_it = NULL; + for (_data_->prov_it = _data_->prov_collection; _data_->prov_it != NULL; _data_->prov_it = _data_->prov_it->next) { + _data_->prov = (DataProvider*) _data_->prov_it->data; + { + _data_->enabled = TRUE; + _data_->timestamp = (gint64) 0; +- _data_->_tmp23_ = _data_->self->priv->sources_info; ++ _data_->_tmp24_ = _data_->self->priv->sources_info; + { +- _data_->src_collection = _data_->_tmp23_; ++ _data_->src_collection = _data_->_tmp24_; + _data_->src_it = NULL; + for (_data_->src_it = _data_->src_collection; _data_->src_it != NULL; _data_->src_it = _data_->src_it->next) { +- _data_->_tmp24_ = _g_object_ref0 ((ZeitgeistDataSource*) _data_->src_it->data); +- _data_->src = _data_->_tmp24_; ++ _data_->_tmp25_ = _g_object_ref0 ((ZeitgeistDataSource*) _data_->src_it->data); ++ _data_->src = _data_->_tmp25_; + { +- _data_->_tmp25_ = _data_->src; +- _data_->_tmp26_ = NULL; +- _data_->_tmp26_ = zeitgeist_data_source_get_unique_id (_data_->_tmp25_); +- _data_->_tmp27_ = _data_->prov; +- _data_->_tmp28_ = data_provider_get_unique_id (_data_->_tmp27_); +- _data_->_tmp29_ = _data_->_tmp28_; +- if (g_strcmp0 (_data_->_tmp26_, _data_->_tmp29_) == 0) { +- _data_->_tmp30_ = _data_->src; +- _data_->_tmp31_ = 0LL; +- _data_->_tmp31_ = zeitgeist_data_source_get_timestamp (_data_->_tmp30_); +- _data_->timestamp = _data_->_tmp31_; ++ _data_->_tmp26_ = _data_->src; ++ _data_->_tmp27_ = NULL; ++ _data_->_tmp27_ = zeitgeist_data_source_get_unique_id (_data_->_tmp26_); ++ _data_->_tmp28_ = _data_->prov; ++ _data_->_tmp29_ = data_provider_get_unique_id (_data_->_tmp28_); ++ _data_->_tmp30_ = _data_->_tmp29_; ++ if (g_strcmp0 (_data_->_tmp27_, _data_->_tmp30_) == 0) { ++ _data_->_tmp31_ = _data_->src; ++ _data_->_tmp32_ = 0LL; ++ _data_->_tmp32_ = zeitgeist_data_source_get_timestamp (_data_->_tmp31_); ++ _data_->timestamp = _data_->_tmp32_; + _g_object_unref0 (_data_->src); + break; + } +@@ -829,50 +845,50 @@ + } + } + } +- _data_->_tmp32_ = _data_->prov; +- _data_->_tmp33_ = data_provider_get_register (_data_->_tmp32_); +- _data_->_tmp34_ = _data_->_tmp33_; +- if (_data_->_tmp34_) { +- _data_->_tmp35_ = _data_->prov; +- _data_->_tmp36_ = data_provider_get_unique_id (_data_->_tmp35_); +- _data_->_tmp37_ = _data_->_tmp36_; +- _data_->_tmp38_ = _data_->prov; +- _data_->_tmp39_ = data_provider_get_name (_data_->_tmp38_); +- _data_->_tmp40_ = _data_->_tmp39_; +- _data_->_tmp41_ = _data_->prov; +- _data_->_tmp42_ = data_provider_get_description (_data_->_tmp41_); +- _data_->_tmp43_ = _data_->_tmp42_; +- _data_->_tmp44_ = g_ptr_array_new (); +- _data_->_tmp45_ = zeitgeist_data_source_new_full (_data_->_tmp37_, _data_->_tmp40_, _data_->_tmp43_, _data_->_tmp44_); +- _data_->_tmp46_ = g_object_ref_sink (_data_->_tmp45_); +- _data_->ds = _data_->_tmp46_; ++ _data_->_tmp33_ = _data_->prov; ++ _data_->_tmp34_ = data_provider_get_register (_data_->_tmp33_); ++ _data_->_tmp35_ = _data_->_tmp34_; ++ if (_data_->_tmp35_) { ++ _data_->_tmp36_ = _data_->prov; ++ _data_->_tmp37_ = data_provider_get_unique_id (_data_->_tmp36_); ++ _data_->_tmp38_ = _data_->_tmp37_; ++ _data_->_tmp39_ = _data_->prov; ++ _data_->_tmp40_ = data_provider_get_name (_data_->_tmp39_); ++ _data_->_tmp41_ = _data_->_tmp40_; ++ _data_->_tmp42_ = _data_->prov; ++ _data_->_tmp43_ = data_provider_get_description (_data_->_tmp42_); ++ _data_->_tmp44_ = _data_->_tmp43_; ++ _data_->_tmp45_ = g_ptr_array_new (); ++ _data_->_tmp46_ = zeitgeist_data_source_new_full (_data_->_tmp38_, _data_->_tmp41_, _data_->_tmp44_, _data_->_tmp45_); ++ _data_->_tmp47_ = g_object_ref_sink (_data_->_tmp46_); ++ _data_->ds = _data_->_tmp47_; + { +- _data_->_tmp47_ = _data_->self->priv->registry; +- _data_->_tmp48_ = _data_->ds; +- _data_->_tmp49_ = _g_object_ref0 (_data_->_tmp48_); ++ _data_->_tmp48_ = _data_->self->priv->registry; ++ _data_->_tmp49_ = _data_->ds; ++ _data_->_tmp50_ = _g_object_ref0 (_data_->_tmp49_); + _data_->_state_ = 2; +- zeitgeist_data_source_registry_register_data_source (_data_->_tmp47_, _data_->_tmp49_, NULL, data_hub_start_data_providers_ready, _data_); ++ zeitgeist_data_source_registry_register_data_source (_data_->_tmp48_, _data_->_tmp50_, NULL, data_hub_start_data_providers_ready, _data_); + return FALSE; + _state_2: +- _data_->_tmp50_ = FALSE; +- _data_->_tmp50_ = zeitgeist_data_source_registry_register_data_source_finish (_data_->_tmp47_, _data_->_res_, &_data_->_inner_error_); +- _data_->_tmp51_ = _data_->_tmp50_; ++ _data_->_tmp51_ = FALSE; ++ _data_->_tmp51_ = zeitgeist_data_source_registry_register_data_source_finish (_data_->_tmp48_, _data_->_res_, &_data_->_inner_error_); ++ _data_->_tmp52_ = _data_->_tmp51_; + if (_data_->_inner_error_ != NULL) { +- goto __catch8_g_error; ++ goto __catch9_g_error; + } +- _data_->enabled = _data_->_tmp51_; ++ _data_->enabled = _data_->_tmp52_; + } +- goto __finally8; +- __catch8_g_error: ++ goto __finally9; ++ __catch9_g_error: + { + _data_->reg_err = _data_->_inner_error_; + _data_->_inner_error_ = NULL; +- _data_->_tmp52_ = _data_->reg_err; +- _data_->_tmp53_ = _data_->_tmp52_->message; +- g_warning ("zeitgeist-datahub.vala:149: %s", _data_->_tmp53_); ++ _data_->_tmp53_ = _data_->reg_err; ++ _data_->_tmp54_ = _data_->_tmp53_->message; ++ g_warning ("zeitgeist-datahub.vala:152: %s", _data_->_tmp54_); + _g_error_free0 (_data_->reg_err); + } +- __finally8: ++ __finally9: + if (_data_->_inner_error_ != NULL) { + _g_object_unref0 (_data_->ds); + g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code); +@@ -881,15 +897,15 @@ + } + _g_object_unref0 (_data_->ds); + } +- _data_->_tmp54_ = _data_->prov; +- g_signal_connect_object (_data_->_tmp54_, "items-available", (GCallback) _data_hub_items_available_data_provider_items_available, _data_->self, 0); +- _data_->_tmp55_ = _data_->enabled; +- if (_data_->_tmp55_) { +- _data_->_tmp56_ = _data_->prov; +- _data_->_tmp57_ = _data_->timestamp; +- data_provider_set_last_timestamp (_data_->_tmp56_, _data_->_tmp57_); +- _data_->_tmp58_ = _data_->prov; +- data_provider_start (_data_->_tmp58_); ++ _data_->_tmp55_ = _data_->prov; ++ g_signal_connect_object (_data_->_tmp55_, "items-available", (GCallback) _data_hub_items_available_data_provider_items_available, _data_->self, 0); ++ _data_->_tmp56_ = _data_->enabled; ++ if (_data_->_tmp56_) { ++ _data_->_tmp57_ = _data_->prov; ++ _data_->_tmp58_ = _data_->timestamp; ++ data_provider_set_last_timestamp (_data_->_tmp57_, _data_->_tmp58_); ++ _data_->_tmp59_ = _data_->prov; ++ data_provider_start (_data_->_tmp59_); + } + } + } +@@ -1004,7 +1020,7 @@ + _tmp0_ = self->priv->queued_events; + _tmp1_ = g_ptr_array_get_length (_tmp0_); + _tmp2_ = _tmp1_; +- g_debug ("zeitgeist-datahub.vala:180: Inserting %u events", (guint) _tmp2_); ++ g_debug ("zeitgeist-datahub.vala:183: Inserting %u events", (guint) _tmp2_); + data_hub_batch_insert_events (self, NULL, NULL); + _tmp3_ = g_ptr_array_new_with_free_func (_g_object_unref0_); + _g_ptr_array_unref0 (self->priv->queued_events); +@@ -1157,20 +1173,20 @@ + _data_->_tmp22_ = _data_->_tmp21_; + _g_array_free0 (_data_->_tmp22_); + if (_data_->_inner_error_ != NULL) { +- goto __catch9_g_error; ++ goto __catch10_g_error; + } + } +- goto __finally9; +- __catch9_g_error: ++ goto __finally10; ++ __catch10_g_error: + { + _data_->err = _data_->_inner_error_; + _data_->_inner_error_ = NULL; + _data_->_tmp23_ = _data_->err; + _data_->_tmp24_ = _data_->_tmp23_->message; +- g_warning ("zeitgeist-datahub.vala:207: Error during inserting events: %s", _data_->_tmp24_); ++ g_warning ("zeitgeist-datahub.vala:210: Error during inserting events: %s", _data_->_tmp24_); + _g_error_free0 (_data_->err); + } +- __finally9: ++ __finally10: + if (_data_->_inner_error_ != NULL) { + _g_ptr_array_free0 (_data_->ptr_arr); + block1_data_unref (_data_->_data1_); +@@ -1226,7 +1242,7 @@ + + + static void __lambda6_ (DataHub* self) { +- g_warning ("zeitgeist-datahub.vala:224: %s", "Unable to get name \"org.gnome.zeitgeist.datahub\"" " on the bus!"); ++ g_warning ("zeitgeist-datahub.vala:227: %s", "Unable to get name \"org.gnome.zeitgeist.datahub\"" " on the bus!"); + data_hub_set_return_code (self, 1); + data_hub_quit (self); + } diff -Nru zeitgeist-datahub-0.8.2/debian/patches/series zeitgeist-datahub-0.8.2/debian/patches/series --- zeitgeist-datahub-0.8.2/debian/patches/series 2012-02-07 08:28:00.000000000 +0000 +++ zeitgeist-datahub-0.8.2/debian/patches/series 2012-04-06 08:16:11.000000000 +0000 @@ -1,3 +1,4 @@ #ignore-patched-files.patch nodisplay_autostart.patch add_datahub_autostart_delay.patch +pre_populator.patch