Merge lp:~3v1n0/unity/zeitgeist-quicklists into lp:unity

[Marco Trevisan (Treviño)]

Implemented design backlog bug #893652 adding quicklist entries with recently used files to launcher icons.

This adds Zeitgeist support to unity, using lp:libzeitgeist through an UnityCore wrapper where I've added two main classes, ZeitgeistApplication and ZeitgeistSubject:

ZeitgeistSubject is a kind of a mix between a pure zeitgeist-event and a native zeitgeist-subject. In fact each ZeitgeistSubject is actually wrapping a native subject, but it has also the references to the native (parent) event id.

ZeitgeistApplication is the main class to be used in unity and allows to define some kinds of event monitors for the given application.
Each application can store also a defined number of subjects received by the monitor and these elements are stored into a deque that acts like a circular-buffer cache.

BamfLauncherIcon use now ZeitgeistApplication to receive the events and to generate the quicklist items with the last recent items. Each .desktop file can disable this list of recent files setting to false the "X-Ayatana-Show-Recent-Files" key.

[lp:~3v1n0/unity/zeitgeist-quicklists]

1978. By Marco Trevisan (Treviño) on 2012-02-15

ZeitgeistApplication: some string optimization...

1979. By Marco Trevisan (Treviño) on 2012-02-15

ZeitgeistApplication: share the instance of ZeitgeistLog, fix memory leaks

1980. By Marco Trevisan (Treviño) on 2012-02-15

BamfLauncherIcon: don't open the content of a quicklist if the uri is empty

1981. By Marco Trevisan (Treviño) on 2012-02-15

ZeitgeistApplication: don't use a pointer to handle the shared log...

1982. By Marco Trevisan (Treviño) on 2012-02-16

ZeitgeistApplication: use manifestation and reorder the received items

[Tim Penhey (thumper)]

> std::string const& basename = glib::String(g_path_get_basename(desktop_file.c_str())).Str();

This takes a reference to a temporary. Remove the "const&" bit.

If you have a shared log, why delete it when the last reference was there? why not let the log just live on?

> UnityCore/ZeitgeistSubject.cpp

Has the same two lines about 6 times. Consider a simple function.

The ZeitgeistSubject is obviously not meant to be inherited from, so please don't add a protected section.
Secondly, please don't use friend. What is wrong with having a public constructor?

As you mentioned, this branch is missing tests. A key question is how to ensure it is working.

What needs to exist for this to work properly? How can we minimally test it?

We need to export the relevant bits through autopilot, then we can have some functional tests that show when we do "stuff" we get "other stuff" showing in the quicklists.

review: Needs Fixing

[Marco Trevisan (Treviño) (3v1n0)]

> > std::string const& basename =
> glib::String(g_path_get_basename(desktop_file.c_str())).Str();
>
> This takes a reference to a temporary. Remove the "const&" bit.

Ok.

> If you have a shared log, why delete it when the last reference was there?
> why not let the log just live on?
>
> > UnityCore/ZeitgeistSubject.cpp
>
> Has the same two lines about 6 times. Consider a simple function.

That's something I was thinking on, but I didn't like to do something like that just for this case (also considering that I'm repeating something that is not so different from calling a shared function).
I think that this a reason why can make sense supporting const strings in glib::String as I told some time ago... Wouldn't be better something like this: http://paste.ubuntu.com/860690/ ?

> The ZeitgeistSubject is obviously not meant to be inherited from, so please
> don't add a protected section.

Sure, I added it for another reason... Then I forgot to change it.

> Secondly, please don't use friend. What is wrong with having a public
> constructor?

I know that friend classes aren't the best thing, but I neither loved the idea of allowing everybody to construct a ZeitgeistSubject, as that's something that only a ZetigeistApplication should be able to provide. But if you prefer to avoid to use friends, I'll move it out.

> As you mentioned, this branch is missing tests. A key question is how to
> ensure it is working.
>
> What needs to exist for this to work properly? How can we minimally test it?

In the real world we'd need to create a new zeitgeist application, install a monitor on it, and check that we get some subjects both when the monitor is installed (if there are events for that) and when we open a new file with the given application.

Testing it through a mock would be maybe useless to really check that this is working.

> We need to export the relevant bits through autopilot, then we can have some
> functional tests that show when we do "stuff" we get "other stuff" showing in
> the quicklists.

I see what I can do on this.

[Marco Trevisan (Treviño) (3v1n0)]

Ah, I forgot to reply at:

> If you have a shared log, why delete it when the last reference was there?
> why not let the log just live on?

Well, why should we leak memory if no one really needs a log?
When all the applications that have used a log are destroyed, we make sure that our log is removed... Maybe I could just switch to zetigeist_log_get_default, but it wouldn't be destroyed anyway when all the Application instances would be removed.

[lp:~3v1n0/unity/zeitgeist-quicklists]

1983. By Marco Trevisan (Treviño) on 2012-02-26

Merging with trunk

1984. By Marco Trevisan (Treviño) on 2012-02-28

glib::String: add support for constant strings

1985. By Marco Trevisan (Treviño) on 2012-02-28

ZeitgeistSubject: moving to glib::String with const support.

1986. By Marco Trevisan (Treviño) on 2012-02-28

ZeitgeistSubject: setting the constructor private.

[Michal Hruby (mhr3)]

112 + explicit String(const gchar* str);

Woooo, no, no, no, the glib::String class is meant to own the string, this way it can easily break if the real owner goes out of scope, we definitely don't want that kind of breakage.

[lp:~3v1n0/unity/zeitgeist-quicklists]

1987. By Marco Trevisan (Treviño) on 2012-02-28

Removing debug test code

1988. By Marco Trevisan (Treviño) on 2012-02-28

ZeitgeistSubject: add GetConstString to stafely convert gchar* to std::string

[Marco Trevisan (Treviño) (3v1n0)]

> 112 + explicit String(const gchar* str);
>
> Woooo, no, no, no, the glib::String class is meant to own the string, this way
> it can easily break if the real owner goes out of scope, we definitely don't
> want that kind of breakage.

It didn't look so bad to me as I don't think it would introduce any breakage that using a simple const gchar* wouldn't, but if that's your thinking, I go back to the Tim's advice, even if it's out of scope there, imho.

Unmerged revisions

1988. By Marco Trevisan (Treviño) on 2012-02-28

ZeitgeistSubject: add GetConstString to stafely convert gchar* to std::string

1987. By Marco Trevisan (Treviño) on 2012-02-28

Removing debug test code

1986. By Marco Trevisan (Treviño) on 2012-02-28

ZeitgeistSubject: setting the constructor private.

1985. By Marco Trevisan (Treviño) on 2012-02-28

ZeitgeistSubject: moving to glib::String with const support.

1984. By Marco Trevisan (Treviño) on 2012-02-28

glib::String: add support for constant strings

1983. By Marco Trevisan (Treviño) on 2012-02-26

Merging with trunk

1982. By Marco Trevisan (Treviño) on 2012-02-16

ZeitgeistApplication: use manifestation and reorder the received items

1981. By Marco Trevisan (Treviño) on 2012-02-15

ZeitgeistApplication: don't use a pointer to handle the shared log...

1980. By Marco Trevisan (Treviño) on 2012-02-15

BamfLauncherIcon: don't open the content of a quicklist if the uri is empty

1979. By Marco Trevisan (Treviño) on 2012-02-15

ZeitgeistApplication: share the instance of ZeitgeistLog, fix memory leaks

=== modified file 'CMakeLists.txt'
--- CMakeLists.txt	2012-02-23 07:43:46 +0000
+++ CMakeLists.txt	2012-02-28 17:40:24 +0000
@@ -122,7 +122,7 @@
 #
 # Compiz Plugins
 #
-set (UNITY_PLUGIN_DEPS "compiz;nux-2.0>=2.0.0;libbamf3;dee-1.0;gio-2.0;gio-unix-2.0;dbusmenu-glib-0.4;x11;libstartup-notification-1.0;gthread-2.0;indicator3-0.4;atk;unity-misc>=0.4.0;gconf-2.0;libutouch-geis;gtk+-3.0>=3.1;sigc++-2.0;json-glib-1.0;libnotify;gnome-desktop-3.0;gdu")
+set (UNITY_PLUGIN_DEPS "compiz;nux-2.0>=2.0.0;libbamf3;dee-1.0;gio-2.0;gio-unix-2.0;dbusmenu-glib-0.4;x11;libstartup-notification-1.0;gthread-2.0;indicator3-0.4;atk;unity-misc>=0.4.0;gconf-2.0;libutouch-geis;gtk+-3.0>=3.1;sigc++-2.0;json-glib-1.0;libnotify;gnome-desktop-3.0;gdu;zeitgeist-1.0")
 
 add_subdirectory(plugins/unityshell)
 add_subdirectory(plugins/gtkloader)

=== modified file 'UnityCore/CMakeLists.txt'
--- UnityCore/CMakeLists.txt	2012-02-07 07:42:12 +0000
+++ UnityCore/CMakeLists.txt	2012-02-28 17:40:24 +0000
@@ -1,5 +1,5 @@
 find_package (PkgConfig)
-pkg_check_modules (CORE_DEPS REQUIRED glib-2.0 gio-2.0 dee-1.0 sigc++-2.0 nux-core-2.0 gdk-pixbuf-2.0 unity)
+pkg_check_modules (CORE_DEPS REQUIRED glib-2.0 gio-2.0 dee-1.0 sigc++-2.0 nux-core-2.0 gdk-pixbuf-2.0 unity zeitgeist-1.0)
 
 execute_process (COMMAND ${PKG_CONFIG_EXECUTABLE} unity --variable lensesdir OUTPUT_VARIABLE _lensesdir OUTPUT_STRIP_TRAILING_WHITESPACE)
 
@@ -40,6 +40,8 @@
      Result.h
      Results.h
      Variant.h
+     ZeitgeistApplication.h
+     ZeitgeistSubject.h
     )
 
 set (CORE_SOURCES
@@ -70,6 +72,8 @@
      Result.cpp
      Results.cpp
      Variant.cpp
+     ZeitgeistApplication.cpp
+     ZeitgeistSubject.cpp
     )
 
 #

=== added file 'UnityCore/ZeitgeistApplication.cpp'
--- UnityCore/ZeitgeistApplication.cpp	1970-01-01 00:00:00 +0000
+++ UnityCore/ZeitgeistApplication.cpp	2012-02-28 17:40:24 +0000
@@ -0,0 +1,269 @@
+// -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
+/*
+ * Copyright (C) 2012 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Marco Trevisan (Treviño) <[e-mail]>
+ */
+
+#include "ZeitgeistApplication.h"
+
+namespace unity
+{
+namespace zeitgeist
+{
+static glib::Object<ZeitgeistLog> shared_log_;
+
+Application::Application(std::string const& desktop_file)
+  : application_event_(zeitgeist_event_new())
+{
+  if (!shared_log_ || !ZEITGEIST_IS_LOG(shared_log_.RawPtr()))
+  {
+    shared_log_ = glib::Object<ZeitgeistLog>(zeitgeist_log_new());
+  }
+
+  log_ = shared_log_;
+
+  if (!desktop_file.empty())
+  {
+    std::string basename = glib::String(g_path_get_basename(desktop_file.c_str())).Str();
+
+    if (!basename.empty())
+    {
+      const std::string prefix = "application://";
+      application_uri_ = prefix + basename;
+
+      ZeitgeistSubject* subj = zeitgeist_subject_new();
+      glib::Object<ZeitgeistSubject> application_subject(subj, glib::AddRef());
+      zeitgeist_subject_set_manifestation(application_subject, "!" ZEITGEIST_NFO_SOFTWARE_ITEM);
+      zeitgeist_event_add_subject(application_event_, application_subject);
+      zeitgeist_event_set_actor(application_event_, application_uri_.c_str());
+    }
+  }
+}
+
+Application::~Application()
+{
+  if (ZEITGEIST_IS_LOG(shared_log_.RawPtr()))
+  {
+    auto glog = reinterpret_cast<GObject*>(shared_log_.RawPtr());
+
+    /* If the log has 2 references we can safely nullify the shared instance
+     * In fact, at this point both the application log_ member and the
+     * shared member owns a reference, that's why of this "magic" number */
+    if (glog->ref_count == 2)
+    {
+      shared_log_ = nullptr;
+    }
+  }
+  else if (shared_log_)
+  {
+    shared_log_ = nullptr;
+  }
+}
+
+std::string const& Application::Uri() const
+{
+  return application_uri_;
+}
+
+ZeitgeistResultType Application::GetResultTypeByMonitorType(MonitorType mtype)
+{
+  switch (mtype)
+  {
+    case MOST_RECENT_EVENTS:
+      return ZEITGEIST_RESULT_TYPE_MOST_RECENT_EVENTS;
+    case LEAST_RECENT_EVENTS:
+      return ZEITGEIST_RESULT_TYPE_LEAST_RECENT_EVENTS;
+    case MOST_RECENT_SUBJECTS:
+      return ZEITGEIST_RESULT_TYPE_MOST_RECENT_SUBJECTS;
+    case LEAST_RECENT_SUBJECTS:
+      return ZEITGEIST_RESULT_TYPE_LEAST_RECENT_SUBJECTS;
+    case MOST_POPULAR_SUBJECTS:
+      return ZEITGEIST_RESULT_TYPE_MOST_POPULAR_SUBJECTS;
+    case LEAST_POPULAR_SUBJECTS:
+      return ZEITGEIST_RESULT_TYPE_LEAST_POPULAR_SUBJECTS;
+    default:
+      return ZEITGEIST_RESULT_TYPE_RELEVANCY;
+  }
+}
+
+void Application::HandleResultSet(glib::Object<ZeitgeistResultSet> const& results, MonitorType mtype)
+{
+  Subjects& subjects = subjects_[mtype];
+  std::deque<std::pair<ZeitgeistEvent*, ZeitgeistSubject*>> new_subjects;
+  unsigned int max_items = subjects_pools_[mtype];
+
+  // Reversing the list of the new items.
+  while (zeitgeist_result_set_has_next(results))
+  {
+    ZeitgeistEvent* event = zeitgeist_result_set_next(results);
+
+    for (int i = 0; i < zeitgeist_event_num_subjects(event); ++i)
+    {
+      ZeitgeistSubject* subj = zeitgeist_event_get_subject(event, i);
+      if (!ZEITGEIST_IS_SUBJECT(subj))
+        continue;
+
+      std::pair<ZeitgeistEvent*, ZeitgeistSubject*> new_event(event, subj);
+      new_subjects.push_front(new_event);
+    }
+  }
+
+  for (auto new_pair : new_subjects)
+  {
+    ZeitgeistEvent* event = new_pair.first;
+    guint32 event_id = zeitgeist_event_get_id(event);
+    gint64 timestamp = zeitgeist_event_get_timestamp(event);
+
+    glib::Object<ZeitgeistSubject> gsubject(new_pair.second, glib::AddRef());
+    Subject::Ptr subject_ptr(new Subject(gsubject, event_id, timestamp));
+
+    for (auto it = subjects.begin(); it != subjects.end(); ++it)
+    {
+      if ((*it)->Uri() == subject_ptr->Uri())
+      {
+        subject_removed.emit(mtype, *it);
+        subjects.erase(it);
+        break;
+      }
+    }
+
+    if (subjects.size() == max_items)
+    {
+      subject_removed.emit(mtype, subjects.front());
+      subjects.pop_front();
+    }
+
+    subjects.push_back(subject_ptr);
+    subject_added.emit(mtype, subject_ptr);
+  }
+}
+
+void Application::AddMonitor(MonitorType mtype, unsigned int pool_size)
+{
+  if (monitors_.find(mtype) != monitors_.end() || pool_size == 0)
+  {
+    return;
+  }
+
+  glib::Object<ZeitgeistTimeRange> time_range(zeitgeist_time_range_new_to_now());
+
+  // This must not be free'd, libzeitgeist will take care of it.
+  GPtrArray* event_template = g_ptr_array_sized_new(1);
+  glib::Object<ZeitgeistEvent> event(application_event_, glib::AddRef());
+  g_ptr_array_add(event_template, event);
+
+  subjects_pools_[mtype] = pool_size;
+
+  struct FindEventsData
+  {
+    Application* self;
+    Application::MonitorType type;
+  };
+
+  auto data = new FindEventsData();
+  data->self = this;
+  data->type = mtype;
+
+  zeitgeist_log_find_events(log_, time_range, event_template, ZEITGEIST_STORAGE_STATE_AVAILABLE,
+                            pool_size, GetResultTypeByMonitorType(mtype), nullptr,
+                            [] (GObject* object, GAsyncResult* res, gpointer data)
+                            {
+                              glib::Error error;
+                              glib::Object<ZeitgeistResultSet> results;
+                              auto find_data = static_cast<FindEventsData*>(data);
+                              auto log = reinterpret_cast<ZeitgeistLog*>(object);
+
+                              results = zeitgeist_log_find_events_finish(log, res, &error);
+
+                              if (!error)
+                                find_data->self->HandleResultSet(results, find_data->type);
+
+                              delete find_data;
+                            },
+                            data);
+
+  GPtrArray* monitor_template = g_ptr_array_sized_new(1);
+  g_ptr_array_add(monitor_template, event);
+
+  glib::Object<ZeitgeistTimeRange> monitor_time_range(zeitgeist_time_range_new_from_now(), glib::AddRef()); 
+  glib::Object<ZeitgeistMonitor> monitor(zeitgeist_monitor_new(monitor_time_range, monitor_template), glib::AddRef());
+  g_object_set_data(glib::object_cast<GObject>(monitor), "monitor-type", GUINT_TO_POINTER(mtype));
+
+  monitors_[mtype] = monitor;
+  zeitgeist_log_install_monitor(log_, monitor);
+
+  typedef glib::Signal<void, ZeitgeistMonitor*, ZeitgeistTimeRange*, ZeitgeistResultSet*> EventsAddedSignal;
+
+  signal_manager_.Add(new EventsAddedSignal(monitor, "events-inserted",
+                      [&] (ZeitgeistMonitor* zmon, ZeitgeistTimeRange* tm, ZeitgeistResultSet* events)
+                      {
+                        glib::Object<ZeitgeistTimeRange> time(tm);
+                        glib::Object<ZeitgeistResultSet> results(events);
+                        gpointer data = g_object_get_data(reinterpret_cast<GObject*>(zmon), "monitor-type");
+                        HandleResultSet(results, static_cast<MonitorType>(GPOINTER_TO_UINT(data)));
+                      }));
+
+  typedef glib::Signal<void, ZeitgeistMonitor*, ZeitgeistTimeRange*, GArray*> EventsDeletedSignal;
+
+  signal_manager_.Add(new EventsDeletedSignal(monitor, "events-deleted",
+                      [&] (ZeitgeistMonitor* zmon, ZeitgeistTimeRange* tm, GArray* events)
+                      {
+                        glib::Object<ZeitgeistTimeRange> time(tm);
+                        gpointer data = g_object_get_data(reinterpret_cast<GObject*>(zmon), "monitor-type");
+                        MonitorType mon_type = static_cast<MonitorType>(GPOINTER_TO_UINT(data));
+
+                        Subjects& subjects = subjects_[mon_type];
+                        std::vector<Subjects::iterator> to_rm;
+
+                        for (unsigned int i = 0; events && i < events->len; ++i)
+                        {
+                          guint32 event_id = g_array_index(events, guint32, i);
+
+                          for (auto it = subjects.begin(); it != subjects.end(); ++it)
+                          {
+                            if ((*it)->EventId() == event_id)
+                            {
+                              subject_removed.emit(mon_type, *it);
+                              to_rm.push_back(it);
+                            }
+                          }
+                        }
+
+                        for (auto subject_it : to_rm)
+                          subjects.erase(subject_it);
+
+                        g_array_unref(events);
+                      }));
+}
+
+void Application::RemoveMonitor(MonitorType mtype)
+{
+  if (monitors_.find(mtype) == monitors_.end())
+    return;
+
+  glib::Object<ZeitgeistMonitor> &monitor = monitors_[mtype];
+  signal_manager_.Disconnect(monitor.RawPtr(), "events-inserted");
+  signal_manager_.Disconnect(monitor.RawPtr(), "events-deleted");
+
+  for (auto subject : subjects_[mtype])
+    subject_removed.emit(mtype, subject);
+
+  subjects_.erase(mtype);
+  monitors_.erase(mtype);
+}
+
+}
+}

=== added file 'UnityCore/ZeitgeistApplication.h'
--- UnityCore/ZeitgeistApplication.h	1970-01-01 00:00:00 +0000
+++ UnityCore/ZeitgeistApplication.h	2012-02-28 17:40:24 +0000
@@ -0,0 +1,86 @@
+// -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
+/*
+ * Copyright (C) 2012 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Marco Trevisan (Treviño) <[e-mail]>
+ */
+
+#ifndef UNITY_ZEITGEIST_APPLICATION_H
+#define UNITY_ZEITGEIST_APPLICATION_H
+
+#include <zeitgeist.h>
+
+#include <sigc++/signal.h>
+#include <deque>
+#include <map>
+
+#include "ZeitgeistSubject.h"
+#include "GLibSignal.h"
+
+namespace unity
+{
+namespace zeitgeist
+{
+
+class Application : public sigc::trackable, boost::noncopyable
+{
+public:
+  typedef boost::shared_ptr<Application> Ptr;
+  typedef std::deque<Subject::Ptr> Subjects;
+
+  Application(std::string const& desktop_file);
+  ~Application();
+
+  enum MonitorType
+  {
+    MOST_RECENT_EVENTS = 1,
+    LEAST_RECENT_EVENTS,
+    MOST_RECENT_SUBJECTS,
+    LEAST_RECENT_SUBJECTS,
+    MOST_POPULAR_SUBJECTS,
+    LEAST_POPULAR_SUBJECTS,
+    RELEVANCY
+  };
+
+  std::string const& Uri() const;
+
+  void AddMonitor(MonitorType type, unsigned int pool_size = 10);
+  void RemoveMonitor(MonitorType type);
+
+  Subjects GetSubjectsForMonitor(MonitorType type) const;
+
+  // Signals
+  sigc::signal<void, MonitorType, Subject::Ptr const&> subject_added;
+  sigc::signal<void, MonitorType, Subject::Ptr const&> subject_removed;
+
+private:
+  ZeitgeistResultType GetResultTypeByMonitorType(MonitorType mtype);
+  void HandleResultSet(glib::Object<ZeitgeistResultSet> const& results, MonitorType mtype);
+
+  glib::Object<ZeitgeistLog> log_;
+  glib::Object<ZeitgeistEvent> application_event_;
+  std::string application_uri_;
+  glib::SignalManager signal_manager_;
+
+  std::map<MonitorType, glib::Object<ZeitgeistMonitor>> monitors_;
+  std::map<MonitorType, Subjects> subjects_;
+  std::map<MonitorType, unsigned int> subjects_pools_;
+};
+
+
+}
+}
+
+#endif // UNITY_ZEITGEIST_APPLICATION_H

=== added file 'UnityCore/ZeitgeistSubject.cpp'
--- UnityCore/ZeitgeistSubject.cpp	1970-01-01 00:00:00 +0000
+++ UnityCore/ZeitgeistSubject.cpp	2012-02-28 17:40:24 +0000
@@ -0,0 +1,91 @@
+// -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
+/*
+ * Copyright (C) 2012 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Marco Trevisan (Treviño) <[e-mail]>
+ */
+
+#include "ZeitgeistSubject.h"
+
+namespace unity
+{
+namespace zeitgeist
+{
+
+Subject::Subject(glib::Object<ZeitgeistSubject> const& subject, unsigned int id, long long timestamp)
+  : subject_(subject, glib::AddRef()),
+    event_id_(id),
+    event_timestamp_(timestamp)
+{}
+
+unsigned int Subject::EventId() const
+{
+  return event_id_;
+}
+
+long long Subject::EventTimestamp() const
+{
+  return event_timestamp_;
+}
+
+std::string Subject::GetConstString(const gchar* str)
+{
+  return (str) ? str : "";
+}
+
+std::string Subject::Interpretation() const
+{
+  const gchar* str = zeitgeist_subject_get_interpretation(subject_);
+  return GetConstString(str);
+}
+
+std::string Subject::Manifestation() const
+{
+  const gchar* str = zeitgeist_subject_get_manifestation(subject_);
+  return GetConstString(str);
+}
+
+std::string Subject::MimeType() const
+{
+  const gchar* str = zeitgeist_subject_get_mimetype(subject_);
+  return GetConstString(str);
+}
+
+std::string Subject::Origin() const
+{
+  const gchar* str = zeitgeist_subject_get_origin(subject_);
+  return GetConstString(str);
+}
+
+std::string Subject::Storage() const
+{
+  const gchar* str = zeitgeist_subject_get_storage(subject_);
+  return GetConstString(str);
+}
+
+std::string Subject::Text() const
+{
+  const gchar* str = zeitgeist_subject_get_text(subject_);
+  return GetConstString(str);
+}
+
+std::string Subject::Uri() const
+{
+  const gchar* str = zeitgeist_subject_get_uri(subject_);
+  return GetConstString(str);
+}
+
+} // namespace zeitgeist
+} // namespace unity

=== added file 'UnityCore/ZeitgeistSubject.h'
--- UnityCore/ZeitgeistSubject.h	1970-01-01 00:00:00 +0000
+++ UnityCore/ZeitgeistSubject.h	2012-02-28 17:40:24 +0000
@@ -0,0 +1,64 @@
+// -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
+/*
+ * Copyright (C) 2012 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Marco Trevisan (Treviño) <[e-mail]>
+ */
+
+#ifndef UNITY_ZEITGEIST_SUBJECT_H
+#define UNITY_ZEITGEIST_SUBJECT_H
+
+#include <zeitgeist.h>
+#include <boost/utility.hpp>
+#include <boost/shared_ptr.hpp>
+
+#include "GLibWrapper.h"
+
+namespace unity
+{
+namespace zeitgeist
+{
+
+class Subject : public boost::noncopyable
+{
+public:
+  typedef boost::shared_ptr<Subject> Ptr;
+
+  unsigned int EventId() const;
+  long long EventTimestamp() const;
+
+  std::string Interpretation() const;
+  std::string Manifestation() const;
+  std::string MimeType() const;
+  std::string Origin() const;
+  std::string Storage() const;
+  std::string Text() const;
+  std::string Uri() const;
+
+private:
+  Subject(glib::Object<ZeitgeistSubject> const& subject, unsigned int id, long long timestamp);
+  static std::string GetConstString(const gchar* str);
+
+  glib::Object<ZeitgeistSubject> subject_;
+  unsigned int event_id_;
+  long long event_timestamp_;
+
+  friend class Application;
+};
+
+}
+}
+
+#endif // UNITY_ZEITGEIST_SUBJECT_H

=== modified file 'plugins/unityshell/src/BamfLauncherIcon.cpp'
--- plugins/unityshell/src/BamfLauncherIcon.cpp	2012-02-22 02:17:08 +0000
+++ plugins/unityshell/src/BamfLauncherIcon.cpp	2012-02-28 17:40:24 +0000
@@ -70,52 +70,52 @@
   glib::SignalBase* sig;
 
   sig = new glib::Signal<void, BamfView*, BamfView*>(bamf_view, "child-added",
-                          [&] (BamfView*, BamfView*) {
-                            EnsureWindowState();
-                            UpdateMenus();
-                            UpdateIconGeometries(GetCenters());
-                          });
+              [&] (BamfView*, BamfView*) {
+                EnsureWindowState();
+                UpdateMenus();
+                UpdateIconGeometries(GetCenters());
+              });
   _gsignals.Add(sig);
 
   sig = new glib::Signal<void, BamfView*, BamfView*>(bamf_view, "child-removed",
                           [&] (BamfView*, BamfView*) { EnsureWindowState(); });
   _gsignals.Add(sig);
 
-  sig = new glib::Signal<void, BamfView*, gboolean>(bamf_view, "urgent-changed",
-                          [&] (BamfView*, gboolean urgent) {
-                            SetQuirk(QUIRK_URGENT, urgent);
-                          });
-  _gsignals.Add(sig);
-
-  sig = new glib::Signal<void, BamfView*, gboolean>(bamf_view, "active-changed",
-                          [&] (BamfView*, gboolean active) {
-                            SetQuirk(QUIRK_ACTIVE, active);
-                          });
-  _gsignals.Add(sig);
-
-  sig = new glib::Signal<void, BamfView*, gboolean>(bamf_view, "running-changed",
-                          [&] (BamfView*, gboolean running) {
-                            SetQuirk(QUIRK_RUNNING, running);
-                            if (running)
-                            {
-                              EnsureWindowState();
-                              UpdateIconGeometries(GetCenters());
-                            }
-                          });
-  _gsignals.Add(sig);
-
-  sig = new glib::Signal<void, BamfView*, gboolean>(bamf_view, "user-visible-changed",
-                          [&] (BamfView*, gboolean visible) {
-                            if (!IsSticky())
-                              SetQuirk(QUIRK_VISIBLE, visible);
-                          });
+  sig = new BamfPropertyChangedSignal(bamf_view, "urgent-changed",
+              [&] (BamfView*, gboolean urgent) {
+                SetQuirk(QUIRK_URGENT, urgent);
+              });
+  _gsignals.Add(sig);
+
+  sig = new BamfPropertyChangedSignal(bamf_view, "active-changed",
+              [&] (BamfView*, gboolean active) {
+                SetQuirk(QUIRK_ACTIVE, active);
+              });
+  _gsignals.Add(sig);
+
+  sig = new BamfPropertyChangedSignal(bamf_view, "running-changed",
+              [&] (BamfView*, gboolean running) {
+                SetQuirk(QUIRK_RUNNING, running);
+                if (running)
+                {
+                  EnsureWindowState();
+                  UpdateIconGeometries(GetCenters());
+                }
+              });
+  _gsignals.Add(sig);
+
+  sig = new BamfPropertyChangedSignal(bamf_view, "user-visible-changed",
+              [&] (BamfView*, gboolean visible) {
+                if (!IsSticky())
+                  SetQuirk(QUIRK_VISIBLE, visible);
+              });
   _gsignals.Add(sig);
 
   sig = new glib::Signal<void, BamfView*>(bamf_view, "closed",
-                          [&] (BamfView*) {
-                            if (!IsSticky())
-                              Remove();
-                          });
+              [&] (BamfView*) {
+                if (!IsSticky())
+                  Remove();
+              });
   _gsignals.Add(sig);
 
   WindowManager::Default()->window_minimized.connect(sigc::mem_fun(this, &BamfLauncherIcon::OnWindowMinimized));
@@ -126,6 +126,7 @@
   EnsureWindowState();
   UpdateMenus();
   UpdateDesktopFile();
+  SetupZeitgeistMonitor();
 
   // hack
   SetProgress(0.0f);
@@ -416,6 +417,7 @@
                                       break;
                                     case G_FILE_MONITOR_EVENT_CHANGES_DONE_HINT:
                                       UpdateDesktopQuickList();
+                                      SetupZeitgeistMonitor();
                                       break;
                                     default:
                                       break;
@@ -707,12 +709,12 @@
       dbusmenu_menuitem_property_set_bool(item, DBUSMENU_MENUITEM_PROP_VISIBLE, TRUE);
       dbusmenu_menuitem_property_set(item, "shortcut-nick", nicks[index]);
 
-      auto sig = new glib::Signal<void, DbusmenuMenuitem*, gint>(item, "item-activated",
-                                  [&] (DbusmenuMenuitem* item, gint) {
-                                    const gchar *nick;
-                                    nick = dbusmenu_menuitem_property_get(item, "shortcut-nick");
-                                    indicator_desktop_shortcuts_nick_exec(_desktop_shortcuts, nick);
-                                  });
+      auto sig = new MenuitemActivateSignal(item, "item-activated",
+                      [&] (DbusmenuMenuitem* item, gint) {
+                        const gchar *nick;
+                        nick = dbusmenu_menuitem_property_get(item, "shortcut-nick");
+                        indicator_desktop_shortcuts_nick_exec(_desktop_shortcuts, nick);
+                      });
       _gsignals.Add(sig);
 
       dbusmenu_menuitem_child_append(_menu_desktop_shortcuts, item);
@@ -837,10 +839,10 @@
     dbusmenu_menuitem_property_set_bool(menu_item, DBUSMENU_MENUITEM_PROP_ENABLED, true);
     dbusmenu_menuitem_property_set_bool(menu_item, DBUSMENU_MENUITEM_PROP_VISIBLE, true);
 
-    _gsignals.Add(new glib::Signal<void, DbusmenuMenuitem*, int>(menu_item, DBUSMENU_MENUITEM_SIGNAL_ITEM_ACTIVATED,
-                                    [&] (DbusmenuMenuitem*, int) {
-                                      ToggleSticky();
-                                    }));
+    _gsignals.Add(new MenuitemActivateSignal(menu_item, DBUSMENU_MENUITEM_SIGNAL_ITEM_ACTIVATED,
+                        [&] (DbusmenuMenuitem*, int) {
+                          ToggleSticky();
+                        }));
 
     _menu_items["Pin"] = glib::Object<DbusmenuMenuitem>(menu_item);
   }
@@ -858,10 +860,10 @@
     dbusmenu_menuitem_property_set_bool(menu_item, DBUSMENU_MENUITEM_PROP_ENABLED, true);
     dbusmenu_menuitem_property_set_bool(menu_item, DBUSMENU_MENUITEM_PROP_VISIBLE, true);
 
-    _gsignals.Add(new glib::Signal<void, DbusmenuMenuitem*, int>(menu_item, DBUSMENU_MENUITEM_SIGNAL_ITEM_ACTIVATED,
-                                    [&] (DbusmenuMenuitem*, int) {
-                                      Quit();
-                                    }));
+    _gsignals.Add(new MenuitemActivateSignal(menu_item, DBUSMENU_MENUITEM_SIGNAL_ITEM_ACTIVATED,
+                        [&] (DbusmenuMenuitem*, int) {
+                          Quit();
+                        }));
 
     _menu_items["Quit"] = glib::Object<DbusmenuMenuitem>(menu_item);
   }
@@ -901,6 +903,7 @@
       }
     }
   }
+  
 
   // FIXME: this should totally be added as a _menu_client
   if (DBUSMENU_IS_MENUITEM(_menu_desktop_shortcuts.RawPtr()))
@@ -960,10 +963,10 @@
                                         "unity-use-markup",
                                         true);
 
-    _gsignals.Add(new glib::Signal<void, DbusmenuMenuitem*, int>(item, DBUSMENU_MENUITEM_SIGNAL_ITEM_ACTIVATED,
-                                    [&] (DbusmenuMenuitem*, int) {
-                                      ActivateLauncherIcon(ActionArg(ActionArg::OTHER, 0));
-                                    }));
+    _gsignals.Add(new MenuitemActivateSignal(item, DBUSMENU_MENUITEM_SIGNAL_ITEM_ACTIVATED,
+                        [&] (DbusmenuMenuitem*, int) {
+                          ActivateLauncherIcon(ActionArg(ActionArg::OTHER, 0));
+                        }));
 
     _menu_items_extra["AppName"] = glib::Object<DbusmenuMenuitem>(item);
   }
@@ -984,6 +987,29 @@
   }
   result.push_back(item);
 
+  for (auto it = _menu_items_zeitgeist.begin(); it != _menu_items_zeitgeist.end(); ++it)
+  {
+    result.push_back(it->second.RawPtr());
+  }
+
+  if (_menu_items_zeitgeist.size() > 0)
+  {
+    auto third_separator = _menu_items_extra.find("ThirdSeparator");
+    if (third_separator != _menu_items_extra.end())
+    {
+      item = third_separator->second;
+    }
+    else
+    {
+      item = dbusmenu_menuitem_new();
+      dbusmenu_menuitem_property_set(item,
+                                     DBUSMENU_MENUITEM_PROP_TYPE,
+                                     DBUSMENU_CLIENT_TYPES_SEPARATOR);
+      _menu_items_extra["ThirdSeparator"] = glib::Object<DbusmenuMenuitem>(item);
+    }
+    result.push_back(item);
+  }
+
   EnsureMenuItemsReady();
 
   for (auto it_m = _menu_items.begin(); it_m != _menu_items.end(); ++it_m)
@@ -1231,6 +1257,99 @@
   }
 }
 
+void BamfLauncherIcon::SetupZeitgeistMonitor()
+{
+  const std::string keyname = "X-Ayatana-Show-Recent-Files";
+  bool enabled = true;
+
+  if (_desktop_file.empty())
+  {
+    enabled = false;
+  }
+  else
+  {
+    glib::Error error;
+    GKeyFile* keyfile = g_key_file_new();
+
+    g_key_file_load_from_file(keyfile, _desktop_file.c_str(), G_KEY_FILE_NONE, &error);
+
+    if (error)
+    {
+      enabled = false;
+      g_key_file_free(keyfile);
+    }
+    else if (g_key_file_has_key(keyfile, G_KEY_FILE_DESKTOP_GROUP, keyname.c_str(), nullptr))
+    {
+      enabled = g_key_file_get_boolean(keyfile, G_KEY_FILE_DESKTOP_GROUP, keyname.c_str(), nullptr);
+    }
+
+    g_key_file_free(keyfile);
+  }
+
+  if (!enabled && _zeitgeist_app.get())
+  {
+    _zeitgeist_app->RemoveMonitor(zeitgeist::Application::MOST_RECENT_SUBJECTS);
+    _zeitgeist_app.reset();
+  }
+  else if (enabled && !_zeitgeist_app.get())
+  {
+    _zeitgeist_app.reset(new zeitgeist::Application(_desktop_file));
+    _zeitgeist_app->subject_added.connect(sigc::mem_fun(this, &BamfLauncherIcon::OnZeitgeistSubjectAdded));
+    _zeitgeist_app->subject_removed.connect(sigc::mem_fun(this, &BamfLauncherIcon::OnZeitgeistSubjectRemoved));
+    _zeitgeist_app->AddMonitor(zeitgeist::Application::MOST_RECENT_SUBJECTS, 5);
+  }
+}
+
+void BamfLauncherIcon::OnZeitgeistSubjectAdded(zeitgeist::Application::MonitorType mtype,
+                                               zeitgeist::Subject::Ptr const& subject)
+{
+  if (mtype != zeitgeist::Application::MOST_RECENT_SUBJECTS)
+    return;
+
+  glib::Object<DbusmenuMenuitem> menu_item(dbusmenu_menuitem_new());
+  dbusmenu_menuitem_property_set(menu_item, DBUSMENU_MENUITEM_PROP_LABEL, subject->Text().c_str());
+  dbusmenu_menuitem_property_set_bool(menu_item, DBUSMENU_MENUITEM_PROP_ENABLED, true);
+  dbusmenu_menuitem_property_set_bool(menu_item, DBUSMENU_MENUITEM_PROP_VISIBLE, true);
+
+  _gsignals.Add(new MenuitemActivateSignal(menu_item, DBUSMENU_MENUITEM_SIGNAL_ITEM_ACTIVATED,
+    [&] (DbusmenuMenuitem* item, int)
+    {
+      for (auto zmenuitem : _menu_items_zeitgeist)
+      {
+        if (zmenuitem.second == item)
+        {
+          std::string const& uri = zmenuitem.first->Uri();
+          if (!uri.empty())
+          {
+            std::set<std::string> uris;
+            uris.insert(uri);
+            OpenInstanceWithUris(uris);
+          }
+          break;
+        }
+      }
+    }));
+
+  _menu_items_zeitgeist.push_front(ZeitgeistMenuitem(subject, menu_item));
+}
+
+void BamfLauncherIcon::OnZeitgeistSubjectRemoved(zeitgeist::Application::MonitorType mtype,
+                                                 zeitgeist::Subject::Ptr const& subject)
+{
+  if (mtype != zeitgeist::Application::MOST_RECENT_SUBJECTS)
+    return;
+
+  for (auto it = _menu_items_zeitgeist.begin(); it != _menu_items_zeitgeist.end(); ++it)
+  {
+    if (it->first == subject)
+    {
+      _gsignals.Disconnect(it->second.RawPtr(), DBUSMENU_MENUITEM_SIGNAL_ITEM_ACTIVATED);
+      _menu_items_zeitgeist.erase(it);
+      break;
+    }
+  }
+}
+
 std::string BamfLauncherIcon::GetName() const
 {
   return "BamfLauncherIcon";

=== modified file 'plugins/unityshell/src/BamfLauncherIcon.h'
--- plugins/unityshell/src/BamfLauncherIcon.h	2012-02-12 10:43:11 +0000
+++ plugins/unityshell/src/BamfLauncherIcon.h	2012-02-28 17:40:24 +0000
@@ -23,6 +23,7 @@
 
 #include <UnityCore/GLibSignal.h>
 #include <UnityCore/GLibWrapper.h>
+#include <UnityCore/ZeitgeistApplication.h>
 
 #include <libbamf/libbamf.h>
 #include <libindicator/indicator-desktop-shortcuts.h>
@@ -93,6 +94,7 @@
   void UpdateMenus();
   void UpdateDesktopQuickList();
   void FillSupportedTypes();
+  void SetupZeitgeistMonitor();
 
   void OpenInstanceWithUris(std::set<std::string> uris);
   void Focus(ActionArg arg);
@@ -100,11 +102,18 @@
 
   void OnWindowMinimized(guint32 xid);
   void OnWindowMoved(guint32 xid);
+  void OnZeitgeistSubjectAdded(zeitgeist::Application::MonitorType mtype,
+                               zeitgeist::Subject::Ptr const& subject);
+  void OnZeitgeistSubjectRemoved(zeitgeist::Application::MonitorType mtype,
+                                 zeitgeist::Subject::Ptr const& subject);
 
   bool OwnsWindow(Window w) const;
 
   const std::set<std::string>& GetSupportedTypes();
 
+  typedef glib::Signal<void, BamfView*, gboolean> BamfPropertyChangedSignal;
+  typedef glib::Signal<void, DbusmenuMenuitem*, int> MenuitemActivateSignal;
+  typedef std::pair<zeitgeist::Subject::Ptr, glib::Object<DbusmenuMenuitem>> ZeitgeistMenuitem;
 
   glib::Object<BamfApplication> _bamf_app;
   bool _dnd_hovered;
@@ -116,10 +125,12 @@
 
   std::string _remote_uri;
   std::string _desktop_file;
+  zeitgeist::Application::Ptr _zeitgeist_app;
   std::set<std::string> _supported_types;
   std::map<std::string, glib::Object<DbusmenuClient>> _menu_clients;
   std::map<std::string, glib::Object<DbusmenuMenuitem>> _menu_items;
   std::map<std::string, glib::Object<DbusmenuMenuitem>> _menu_items_extra;
+  std::deque<ZeitgeistMenuitem> _menu_items_zeitgeist;
   glib::Object<IndicatorDesktopShortcuts> _desktop_shortcuts;
   glib::Object<DbusmenuMenuitem> _menu_desktop_shortcuts;
   glib::Object<GFileMonitor> _desktop_file_monitor;