Merge lp:~elementary-apps/slingshot/synapse-desktop-only into lp:~elementary-pantheon/slingshot/trunk

[Tom Beckmann]

Copy the sources of Synapse over and implements a new searchview using libsynapse

Copying is currently necessary as synapse's library is internal. I hope we can change this soon, although I don't consider it very urgent, as synapse is almost unmaintained at the moment, so we most likely won't miss out on important updates.

This branch copies the sources of synapse over to slingshot and implements a new searchview using libsynapse.

Copying is currently necessary as synapse's library is internal. I hope we can change this soon, although I don't consider it very urgent, as synapse is almost unmaintained at the moment, so we most likely won't miss out on important updates.

There is currently some unused code flying around in that branch, that's because Dan requested to only add the desktop-file-plugin and the command-plugin for now, so we can have something to merge. The features that are currently inaccessible are mainly the context view, which would pull up context actions when you press "tab" on a result and helper stuff like grabbing favicons for internet results, which currently don't get as both the bookmarks plugin and the zeitgeist plugin are disabled.
I would prefer keeping this code though, for one removing it would probably require more work than fixing it (admittedly, testing is where the actual work would currently be needed, but still) and also I think it's all backend related, so at least the code could already be checked for this review.

[lp:~elementary-apps/slingshot/synapse-desktop-only]

438. By Tom Beckmann on 2014-06-12

more code style fixes

[Cody Garver (codygarver)]

/lib/synapse-core/desktop-file-service.vala:333.5-333.39: warning: method `Synapse.DesktopFileService.get_cache_file_name' never used
    private string? get_cache_file_name (string dir_name)
    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

[Cody Garver (codygarver)]

lib/synapse-plugins/desktop-file-plugin.vala:280.35-280.61: warning: Gdk.AppLaunchContext.new has been deprecated since 3.0

lib/synapse-plugins/desktop-file-plugin.vala:115.9-115.30: warning: implicit .begin is deprecated

lib/synapse-plugins/desktop-file-plugin.vala:118.7-118.28: warning: implicit .begin is deprecated

[Cody Garver (codygarver)]

lib/synapse-core/CMakeLists.txt should say

add_definitions(${CORE_DEPS_CFLAGS} -include config.h -w)

lib/synapse-plugins/CMakeLists.txt should say

add_definitions(${PLUGINS_DEPS_CFLAGS} -include config.h -w)

[Sergey "Shnatsel" Davidoff (shnatsel)]

Design-wise, I'd prefer Slingshot to search not yet installed applications when I enter something in the search bar. For example, if I type "GIMP" on a clean system right now, I get nothing and have to go to software center, re-type "GIMP", click install, wait for it to complete, close software center, go to slingshot again, type "GIMP" again, click it. I believe this could be streamlined a lot by searching not yet installed applications and showing them *after* the installed ones with "More info..." and "Install" buttons on it, for people unfamiliar and familiar with the program, respectively.

Such functionality is much more relevant to an application launcher and leaves no room for Synapse, thus I believe that Synapse belongs to its own indicator.

review: Disapprove (ux opinion)

[lp:~elementary-apps/slingshot/synapse-desktop-only]

439. By Tom Beckmann on 2014-06-13

disable c warnings

[Tom Beckmann (tombeckmann)]

@Cody, added -w now. I'd prefer to keep the files by synapse as they are for now, as the final plan is to not have the sources in our project anyway, but if you want me to fix those warnings I can do that too.

[lp:~elementary-apps/slingshot/synapse-desktop-only]

440. By Tom Beckmann on 2014-06-16

actually enable zeitgeist relevancy

[Danielle Foré (danrabbit)]

Cody says he's good on the code side.

I'm good design side. This branch is made to lay a foundation, not introduce any new features yet. We can address additional feature requests in later branches.

review: Approve

=== modified file 'CMakeLists.txt'
--- CMakeLists.txt	2014-05-28 08:48:51 +0000
+++ CMakeLists.txt	2014-06-16 07:45:32 +0000
@@ -54,7 +54,7 @@
   message ("-- Zeitgeist integration disabled")
 endif ()
 
-set (CORE_DEPS "gobject-2.0;glib-2.0;gio-2.0;gio-unix-2.0;gee-0.8;libgnome-menu-3.0;${UNITY_DEPS};")
+set (CORE_DEPS "gobject-2.0;glib-2.0;gio-2.0;gio-unix-2.0;libsoup-2.4;gee-0.8;libgnome-menu-3.0;json-glib-1.0;${UNITY_DEPS};")
 set (UI_DEPS "gtk+-3.0>=3.10.0;granite;${ZEITGEIST_DEPS};")
 
 find_package (PkgConfig)
@@ -74,8 +74,10 @@
     src/Backend/DBusService.vala
     src/Backend/App.vala
     src/Backend/RelevancyService.vala
+    src/Backend/SynapseSearch.vala
     src/Widgets/AppEntry.vala
     src/Widgets/Grid.vala
+    src/Widgets/LargeSearchEntry.vala
     src/Widgets/Switcher.vala
     src/Widgets/SearchView.vala
     src/Widgets/SearchItem.vala
@@ -84,15 +86,25 @@
 PACKAGES
     ${CORE_DEPS}
     ${UI_DEPS}
+    synapse-core
+    synapse-plugins
 CUSTOM_VAPIS
     vapi/config.vapi
 OPTIONS
     --thread
+    --vapidir=${CMAKE_BINARY_DIR}/lib/synapse-core
+    --vapidir=${CMAKE_BINARY_DIR}/lib/synapse-plugins
     -g
     ${UNITY_OPTIONS}
     ${ZEITGEIST_OPTIONS}
 )
 
+include_directories(${CMAKE_BINARY_DIR}/lib/synapse-core)
+include_directories(${CMAKE_BINARY_DIR}/lib/synapse-plugins)
+
+add_subdirectory(lib/synapse-core)
+add_subdirectory(lib/synapse-plugins)
+
 # Comment this out to enable C compiler warnings
 add_definitions (-w)
 
@@ -101,7 +113,7 @@
 link_directories (${DEPS_LIBRARY_DIRS})
 
 add_executable (${APPNAME} ${VALA_C})
-target_link_libraries(${APPNAME} m)
+target_link_libraries(${APPNAME} m synapse-core synapse-plugins)
 
 # Installation
 install (TARGETS ${APPNAME} RUNTIME DESTINATION bin)
@@ -114,4 +126,5 @@
 add_schema ("org.pantheon.desktop.slingshot.gschema.xml")
 
 # Translations
-add_subdirectory (po)
\ No newline at end of file
+add_subdirectory (po)
+

=== added directory 'lib'
=== added directory 'lib/synapse-core'
=== added file 'lib/synapse-core/CMakeLists.txt'
--- lib/synapse-core/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ lib/synapse-core/CMakeLists.txt	2014-06-16 07:45:32 +0000
@@ -0,0 +1,54 @@
+set(CORE_LIB_VERSION 0.1)
+set(CORE_LIB_SOVERSION 0)
+set(CORE_LIBRARY_NAME synapse-core)
+set(CORE_PKG
+    glib-2.0
+    zeitgeist-1.0
+    gio-unix-2.0
+    json-glib-1.0
+    gee-0.8
+    gtk+-3.0
+)
+
+pkg_check_modules(CORE_DEPS REQUIRED ${CORE_PKG})
+
+set(CORE_SOURCE
+    common-actions.vala
+    config-service.vala
+    data-sink.vala
+    dbus-service.vala
+    desktop-file-service.vala
+    match.vala
+    plugin.vala
+    query.vala
+    relevancy-backend-zg.vala
+    relevancy-service.vala
+    result-set.vala
+    utils.vala
+    volume-service.vala
+)
+
+set(LINK_MODE STATIC)
+
+vala_precompile(CORE_VALA_C ${CORE_LIBRARY_NAME}
+    ${CORE_SOURCE}
+PACKAGES
+    ${CORE_PKG}
+GENERATE_VAPI
+    ${CORE_LIBRARY_NAME}
+GENERATE_HEADER
+    ${CORE_LIBRARY_NAME}
+)
+
+add_definitions(${CORE_DEPS_CFLAGS} -include config.h -w)
+link_directories(${CORE_DEPS_LIBRARY_DIRS})
+
+add_library(${CORE_LIBRARY_NAME} STATIC ${CORE_VALA_C})
+target_link_libraries (${CORE_LIBRARY_NAME} ${CORE_DEPS_LIBRARIES})
+
+set_target_properties(${CORE_LIBRARY_NAME} PROPERTIES
+    OUTPUT_NAME ${CORE_LIBRARY_NAME}
+    VERSION ${CORE_LIB_VERSION}
+    SOVERSION ${CORE_LIB_SOVERSION}
+)
+

=== added file 'lib/synapse-core/common-actions.vala'
--- lib/synapse-core/common-actions.vala	1970-01-01 00:00:00 +0000
+++ lib/synapse-core/common-actions.vala	2014-06-16 07:45:32 +0000
@@ -0,0 +1,419 @@
+/*
+ * Copyright (C) 2010 Michal Hruby <[e-mail]>
+ *
+ * This library 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 2.1 of the License, or (at your option) any later version.
+ *
+ * This library 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 <http://www.gnu.org/licenses/>.
+ *
+ * Authored by Michal Hruby <[e-mail]>
+ *
+ */
+
+namespace Synapse
+{
+  public abstract class BaseAction: Object, Match
+  {
+    // from Match interface
+    public string title { get; construct set; }
+    public string description { get; set; }
+    public string icon_name { get; construct set; }
+    public bool has_thumbnail { get; construct set; }
+    public string thumbnail_path { get; construct set; }
+    public MatchType match_type { get; construct set; }
+
+    public int default_relevancy { get; set; }
+    public bool notify_match { get; set; default = true; }
+
+    public abstract bool valid_for_match (Match match);
+    public virtual int get_relevancy_for_match (Match match)
+    {
+      return default_relevancy;
+    }
+
+    public abstract void do_execute (Match? source, Match? target = null);
+    public void execute_with_target (Match? source, Match? target = null)
+    {
+      do_execute (source, target);
+      if (notify_match) source.executed ();
+    }
+    
+    public virtual bool needs_target () {
+      return false;
+    }
+    
+    public virtual QueryFlags target_flags ()
+    {
+      return QueryFlags.ALL;
+    }
+  }
+
+  public class CommonActions: Object, Activatable, ActionProvider
+  {
+    public bool enabled { get; set; default = true; }
+    
+    public void activate ()
+    {
+      
+    }
+
+    public void deactivate ()
+    {
+      
+    }
+
+    private class Runner: BaseAction
+    {
+      public Runner ()
+      {
+        Object (title: _ ("Run"),
+                description: _ ("Run an application, action or script"),
+                icon_name: "system-run", has_thumbnail: false,
+                match_type: MatchType.ACTION,
+                default_relevancy: Match.Score.EXCELLENT);
+      }
+
+      public override void do_execute (Match? match, Match? target = null)
+      {
+        if (match.match_type == MatchType.APPLICATION)
+        {
+          ApplicationMatch? app_match = match as ApplicationMatch;
+          return_if_fail (app_match != null);
+
+          AppInfo app = app_match.app_info ??
+            new DesktopAppInfo.from_filename (app_match.filename);
+
+          try
+          {
+            var display = Gdk.Display.get_default ();
+            app.launch (null, display.get_app_launch_context ());
+            
+            RelevancyService.get_default ().application_launched (app);
+          }
+          catch (Error err)
+          {
+            Utils.Logger.warning (this, "%s", err.message);
+          }
+        }
+        else // MatchType.ACTION
+        {
+          match.execute (null);
+        }
+      }
+
+      public override bool valid_for_match (Match match)
+      {
+        switch (match.match_type)
+        {
+          case MatchType.SEARCH:
+            return true;
+          case MatchType.ACTION:
+            return true;
+          case MatchType.APPLICATION:
+            ApplicationMatch? am = match as ApplicationMatch;
+            return am == null || !am.needs_terminal;
+          default:
+            return false;
+        }
+      }
+    }
+
+    private class TerminalRunner: BaseAction
+    {
+      public TerminalRunner ()
+      {
+        Object (title: _ ("Run in Terminal"),
+                description: _ ("Run application or command in terminal"),
+                icon_name: "terminal", has_thumbnail: false,
+                match_type: MatchType.ACTION,
+                default_relevancy: Match.Score.BELOW_AVERAGE);
+      }
+
+      public override void do_execute (Match? match, Match? target = null)
+      {
+        if (match.match_type == MatchType.APPLICATION)
+        {
+          ApplicationMatch? app_match = match as ApplicationMatch;
+          return_if_fail (app_match != null);
+
+          AppInfo original = app_match.app_info ??
+            new DesktopAppInfo.from_filename (app_match.filename);
+
+          try
+          {
+            AppInfo app = AppInfo.create_from_commandline (
+              original.get_commandline (), original.get_name (),
+              AppInfoCreateFlags.NEEDS_TERMINAL);
+            var display = Gdk.Display.get_default ();
+            app.launch (null, display.get_app_launch_context ());
+          }
+          catch (Error err)
+          {
+            Utils.Logger.warning (this, "%s", err.message);
+          }
+        }
+      }
+
+      public override bool valid_for_match (Match match)
+      {
+        switch (match.match_type)
+        {
+          case MatchType.APPLICATION:
+            ApplicationMatch? am = match as ApplicationMatch;
+            return am != null;
+          default:
+            return false;
+        }
+      }
+    }
+    
+    private class Opener: BaseAction
+    {
+      public Opener ()
+      {
+        Object (title: _ ("Open"),
+                description: _ ("Open using default application"),
+                icon_name: "fileopen", has_thumbnail: false,
+                match_type: MatchType.ACTION,
+                default_relevancy: Match.Score.GOOD);
+      }
+
+      public override void do_execute (Match? match, Match? target = null)
+      {
+        UriMatch uri_match = match as UriMatch;
+
+        if (uri_match != null)
+        {
+          CommonActions.open_uri (uri_match.uri);
+        }
+        else if (file_path.match (match.title))
+        {
+          File f;
+          if (match.title.has_prefix ("~"))
+          {
+            f = File.new_for_path (Path.build_filename (Environment.get_home_dir (),
+                                                        match.title.substring (1),
+                                                        null));
+          }
+          else
+          {
+            f = File.new_for_path (match.title);
+          }
+          CommonActions.open_uri (f.get_uri ());
+        }
+        else
+        {
+          CommonActions.open_uri (match.title);
+        }
+      }
+
+      public override bool valid_for_match (Match match)
+      {
+        switch (match.match_type)
+        {
+          case MatchType.GENERIC_URI:
+            return true;
+          case MatchType.UNKNOWN:
+            return web_uri.match (match.title) || file_path.match (match.title);
+          default:
+            return false;
+        }
+      }
+      
+      private Regex web_uri;
+      private Regex file_path;
+      
+      construct
+      {
+        try
+        {
+          web_uri = new Regex ("^(ftp|http(s)?)://[^.]+\\.[^.]+", RegexCompileFlags.OPTIMIZE);
+          file_path = new Regex ("^(/|~/)[^/]+", RegexCompileFlags.OPTIMIZE);
+        }
+        catch (Error err)
+        {
+          Utils.Logger.warning (this, "%s", err.message);
+        }
+      }
+    }
+
+    private class OpenFolder: BaseAction
+    {
+      public OpenFolder ()
+      {
+        Object (title: _ ("Open folder"),
+                description: _ ("Open folder containing this file"),
+                icon_name: "folder-open", has_thumbnail: false,
+                match_type: MatchType.ACTION,
+                default_relevancy: Match.Score.AVERAGE);
+      }
+
+      public override void do_execute (Match? match, Match? target = null)
+      {
+        UriMatch uri_match = match as UriMatch;
+        return_if_fail (uri_match != null);
+        var f = File.new_for_uri (uri_match.uri);
+        f = f.get_parent ();
+        try
+        {
+          var app_info = f.query_default_handler (null);
+          List<File> files = new List<File> ();
+          files.prepend (f);
+          var display = Gdk.Display.get_default ();
+          app_info.launch (files, display.get_app_launch_context ());
+        }
+        catch (Error err)
+        {
+          Utils.Logger.warning (this, "%s", err.message);
+        }
+      }
+
+      public override bool valid_for_match (Match match)
+      {
+        if (match.match_type != MatchType.GENERIC_URI) return false;
+        UriMatch uri_match = match as UriMatch;
+        var f = File.new_for_uri (uri_match.uri);
+        var parent = f.get_parent ();
+        return parent != null && f.is_native ();
+      }
+    }
+
+    private class ClipboardCopy: BaseAction
+    {
+      public ClipboardCopy ()
+      {
+        Object (title: _ ("Copy to Clipboard"),
+                description: _ ("Copy selection to clipboard"),
+                icon_name: "gtk-copy", has_thumbnail: false,
+                match_type: MatchType.ACTION,
+                default_relevancy: Match.Score.AVERAGE);
+      }
+
+      public override void do_execute (Match? match, Match? target = null)
+      {
+        var cb = Gtk.Clipboard.get (Gdk.Atom.NONE);
+        if (match.match_type == MatchType.GENERIC_URI)
+        {
+          UriMatch uri_match = match as UriMatch;
+          return_if_fail (uri_match != null);
+          
+          /*
+           // just wow, Gtk and also Vala are trying really hard to make this hard to do...
+          Gtk.TargetEntry[] no_entries = {};
+          Gtk.TargetList l = new Gtk.TargetList (no_entries);
+          l.add_uri_targets (0);
+          l.add_text_targets (0);
+          Gtk.TargetEntry te = Gtk.target_table_new_from_list (l, 2);
+          cb.set_with_data ();
+          */
+          cb.set_text (uri_match.uri, -1);
+        }
+        else if (match.match_type == MatchType.TEXT)
+        {
+          TextMatch? text_match = match as TextMatch;
+          string content = text_match != null ? text_match.get_text () : match.title;
+
+          cb.set_text (content, -1);
+        }
+      }
+
+      public override bool valid_for_match (Match match)
+      {
+        switch (match.match_type)
+        {
+          case MatchType.GENERIC_URI:
+            return true;
+          case MatchType.TEXT:
+            return true;
+          default:
+            return false;
+        }
+      }
+      
+      public override int get_relevancy_for_match (Match match)
+      {
+        TextMatch? text_match = match as TextMatch;
+        if (text_match != null && text_match.text_origin == TextOrigin.CLIPBOARD)
+        {
+          return 0;
+        }
+        
+        return default_relevancy;
+      }
+    }
+
+    private Gee.List<BaseAction> actions;
+
+    construct
+    {
+      actions = new Gee.ArrayList<BaseAction> ();
+
+      actions.add (new Runner ());
+      actions.add (new TerminalRunner ());
+      actions.add (new Opener ());
+      actions.add (new OpenFolder ());
+      actions.add (new ClipboardCopy ());
+    }
+
+    public ResultSet? find_for_match (ref Query query, Match match)
+    {
+      bool query_empty = query.query_string == "";
+      var results = new ResultSet ();
+      
+      if (query_empty)
+      {
+        foreach (var action in actions)
+        {
+          if (action.valid_for_match (match))
+          {
+            results.add (action, action.get_relevancy_for_match (match));
+          }
+        }
+      }
+      else
+      {
+        var matchers = Query.get_matchers_for_query (query.query_string, 0,
+          RegexCompileFlags.OPTIMIZE | RegexCompileFlags.CASELESS);
+        foreach (var action in actions)
+        {
+          if (!action.valid_for_match (match)) continue;
+          foreach (var matcher in matchers)
+          {
+            if (matcher.key.match (action.title))
+            {
+              results.add (action, matcher.value);
+              break;
+            }
+          }
+        }
+      }
+
+      return results;
+    }
+    
+    public static void open_uri (string uri)
+    {
+      var f = File.new_for_uri (uri);
+      try
+      {
+        var app_info = f.query_default_handler (null);
+        List<File> files = new List<File> ();
+        files.prepend (f);
+        var display = Gdk.Display.get_default ();
+        app_info.launch (files, display.get_app_launch_context ());
+      }
+      catch (Error err)
+      {
+        Utils.Logger.warning (null, "%s", err.message);
+      }
+    }
+  }
+}

=== added file 'lib/synapse-core/config-service.vala'
--- lib/synapse-core/config-service.vala	1970-01-01 00:00:00 +0000
+++ lib/synapse-core/config-service.vala	2014-06-16 07:45:32 +0000
@@ -0,0 +1,192 @@
+/*
+ * Copyright (C) 2010 Michal Hruby <[e-mail]>
+ *
+ * This library 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 2 of the License, or (at your option) any later version.
+ *
+ * This library 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 <http://www.gnu.org/licenses/>.
+ *
+ * Authored by Michal Hruby <[e-mail]>
+ *
+ */
+
+using Json;
+
+namespace Synapse
+{
+  public abstract class ConfigObject : GLib.Object
+  {
+  }
+
+  public class ConfigService : GLib.Object
+  {
+    // singleton that can be easily destroyed
+    private static unowned ConfigService? instance;
+    public static ConfigService get_default ()
+    {
+      return instance ?? new ConfigService ();
+    }
+
+    private ConfigService ()
+    {
+    }
+    
+    ~ConfigService ()
+    {
+      // useless cause the timer takes a reference on self
+      if (save_timer_id != 0) save ();
+      instance = null;
+    }
+
+    private Json.Node root_node;
+    private string config_file_name;
+    private uint save_timer_id = 0;
+    
+    construct
+    {
+      instance = this;
+      
+      var parser = new Parser ();
+      config_file_name = 
+        GLib.Path.build_filename (Environment.get_user_config_dir (), "synapse",
+                             "config.json");
+      try
+      {
+        parser.load_from_file (config_file_name);
+        root_node = parser.get_root ().copy ();
+        if (root_node.get_node_type () != NodeType.OBJECT)
+        {
+          root_node = new Json.Node (NodeType.OBJECT);
+          root_node.take_object (new Json.Object ());
+        }
+      }
+      catch (Error err)
+      {
+        root_node = new Json.Node (NodeType.OBJECT);
+        root_node.take_object (new Json.Object ());
+      }
+    }
+
+    /**
+     * Creates an instance of an object derived from ConfigObject class, which
+     * will have its public properties set to values stored in config file, or
+     * to the default values if this object wasn't yet stored.
+     *
+     * @param group A group name.
+     * @param key A key name.
+     * @param config_type Type of the object (must be subclass of ConfigObject)
+     * @return An instance of config_type.
+     */
+    public ConfigObject get_config (string group, string key, Type config_type)
+    {
+      unowned Json.Object obj = root_node.get_object ();
+      unowned Json.Node group_node = obj.get_member (group);
+      if (group_node != null)
+      {
+        if (group_node.get_node_type () == NodeType.OBJECT)
+        {
+          unowned Json.Object group_obj = group_node.get_object ();
+          unowned Json.Node key_node = group_obj.get_member (key);
+          if (key_node != null && key_node.get_node_type () == NodeType.OBJECT)
+          {
+            var result = Json.gobject_deserialize (config_type, key_node);
+            return result as ConfigObject;
+          }
+        }
+      }
+      
+      return GLib.Object.new (config_type) as ConfigObject;
+    }
+    
+    /**
+     * Behaves in a similar way to get_config, but it also watches for changes
+     * in the returned config object and saves them back to the config file
+     * (without the need of calling set_config).
+     *
+     * @param group A group name.
+     * @param key A key name.
+     * @param config_type Type of the object (must be subclass of ConfigObject)
+     */
+    public ConfigObject bind_config (string group, string key, Type config_type)
+    {
+      ConfigObject config_object = get_config (group, key, config_type);
+      // make sure the lambda doesn't take a ref on the config_object
+      unowned ConfigObject co = config_object;
+      co.notify.connect (() => { this.set_config (group, key, co); });
+      return config_object;
+    }
+    
+    /**
+     * Stores all public properties of the object to the config file under
+     * specified group and key names.
+     *
+     * @param group A group name.
+     * @param key A key name.
+     * @param cfg_obj ConfigObject instance.
+     */
+    public void set_config (string group, string key, ConfigObject cfg_obj)
+    {
+      unowned Json.Object obj = root_node.get_object ();
+      if (!obj.has_member (group) || 
+          obj.get_member (group).get_node_type () != NodeType.OBJECT)
+      {
+        // why set_object_member works, but set_member doesn't ?!
+        obj.set_object_member (group, new Json.Object ());
+      }
+
+      unowned Json.Object group_obj = obj.get_object_member (group);
+      // why the hell is this necessary?
+      if (group_obj.has_member (key)) group_obj.remove_member (key);
+
+      Json.Node node = Json.gobject_serialize (cfg_obj);
+      group_obj.set_object_member (key, node.get_object ());
+      
+      if (save_timer_id != 0) Source.remove (save_timer_id);
+      // on crap, this takes a reference on self
+      save_timer_id = Timeout.add (30000, this.save_timeout);
+    }
+    
+    private bool save_timeout ()
+    {
+      save_timer_id = 0;
+      save ();
+
+      return false;
+    }
+
+    /**
+     * Forces immediate saving of the configuration file to the filesystem.
+     */
+    public void save ()
+    {
+      if (save_timer_id != 0)
+      {
+        Source.remove (save_timer_id);
+        save_timer_id = 0;
+      }
+      
+      var generator = new Generator ();
+      generator.pretty = true;
+      generator.set_root (root_node);
+
+      DirUtils.create_with_parents (GLib.Path.get_dirname (config_file_name), 0755);
+      try
+      {
+        generator.to_file (config_file_name);
+      }
+      catch (Error err)
+      {
+        warning ("%s", err.message);
+      }
+    }
+  }
+}
+

=== added file 'lib/synapse-core/data-sink.vala'
--- lib/synapse-core/data-sink.vala	1970-01-01 00:00:00 +0000
+++ lib/synapse-core/data-sink.vala	2014-06-16 07:45:32 +0000
@@ -0,0 +1,574 @@
+/*
+ * Copyright (C) 2010 Michal Hruby <[e-mail]>
+ *
+ * This library 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 2.1 of the License, or (at your option) any later version.
+ *
+ * This library 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 <http://www.gnu.org/licenses/>.
+ *
+ * Authored by Michal Hruby <[e-mail]>
+ *
+ */
+
+namespace Synapse
+{
+  public errordomain SearchError
+  {
+    SEARCH_CANCELLED,
+    UNKNOWN_ERROR
+  }
+  
+  public interface SearchProvider : Object
+  {
+    public abstract async Gee.List<Match> search (string query,
+                                                  QueryFlags flags,
+                                                  ResultSet? dest_result_set,
+                                                  Cancellable? cancellable = null) throws SearchError;
+  }
+
+  // don't move into a class, gir doesn't like it
+  [CCode (has_target = false)]
+  public delegate void PluginRegisterFunc ();
+  
+  public class DataSink : Object, SearchProvider
+  {
+    public class PluginRegistry : Object
+    {
+      public class PluginInfo
+      {
+        public Type plugin_type;
+        public string title;
+        public string description;
+        public string icon_name;
+        public PluginRegisterFunc register_func;
+        public bool runnable;
+        public string runnable_error;
+        public PluginInfo (Type type, string title, string desc,
+                           string icon_name, PluginRegisterFunc reg_func,
+                           bool runnable, string runnable_error)
+        {
+          this.plugin_type = type;
+          this.title = title;
+          this.description = desc;
+          this.icon_name = icon_name;
+          this.register_func = reg_func;
+          this.runnable = runnable;
+          this.runnable_error = runnable_error;
+        }
+      }
+
+      public static unowned PluginRegistry instance = null;
+
+      private Gee.List<PluginInfo> plugins;
+      
+      construct
+      {
+        instance = this;
+        plugins = new Gee.ArrayList<PluginInfo> ();
+      }
+      
+      ~PluginRegistry ()
+      {
+        instance = null;
+      }
+      
+      public static PluginRegistry get_default ()
+      {
+        return instance ?? new PluginRegistry ();
+      }
+      
+      public void register_plugin (Type plugin_type,
+                                   string title,
+                                   string description,
+                                   string icon_name,
+                                   PluginRegisterFunc reg_func,
+                                   bool runnable = true,
+                                   string runnable_error = "")
+      {
+        // FIXME: how about a frickin Type -> PluginInfo map?!
+        int index = -1;
+        for (int i=0; i < plugins.size; i++)
+        {
+          if (plugins[i].plugin_type == plugin_type)
+          {
+            index = i;
+            break;
+          }
+        }
+        if (index >= 0) plugins.remove_at (index);
+        
+        var p = new PluginInfo (plugin_type, title, description, icon_name,
+                                reg_func, runnable, runnable_error);
+        plugins.add (p);
+      }
+      
+      public Gee.List<PluginInfo> get_plugins ()
+      {
+        return plugins.read_only_view;
+      }
+      
+      public PluginInfo? get_plugin_info_for_type (Type plugin_type)
+      {
+        foreach (PluginInfo pi in plugins)
+        {
+          if (pi.plugin_type == plugin_type) return pi;
+        }
+        
+        return null;
+      }
+    }
+    
+    private class DataSinkConfiguration : ConfigObject
+    {
+      // vala keeps array lengths, and therefore doesn't support setting arrays
+      // via automatic public properties
+      private string[] _disabled_plugins = null;
+      public string[] disabled_plugins
+      {
+        get
+        {
+          return _disabled_plugins;
+        }
+        set
+        {
+          _disabled_plugins = value;
+        }
+      }
+      
+      public void set_plugin_enabled (Type t, bool enabled)
+      {
+        if (enabled) enable_plugin (t.name ());
+        else disable_plugin (t.name ());
+      }
+      
+      public bool is_plugin_enabled (Type t)
+      {
+        if (_disabled_plugins == null) return true;
+        unowned string plugin_name = t.name ();
+        foreach (string s in _disabled_plugins)
+        {
+          if (s == plugin_name) return false;
+        }
+        return true;
+      }
+      
+      private void enable_plugin (string name)
+      {
+        if (_disabled_plugins == null) return;
+        if (!(name in _disabled_plugins)) return;
+        
+        string[] cpy = {};
+        foreach (string s in _disabled_plugins)
+        {
+          if (s != name) cpy += s;
+        }
+        _disabled_plugins = (owned) cpy;
+      }
+      
+      private void disable_plugin (string name)
+      {
+        if (_disabled_plugins == null || !(name in _disabled_plugins))
+        {
+          _disabled_plugins += name;
+        }
+      }
+    }
+    
+    public DataSink ()
+    {
+    }
+
+    ~DataSink ()
+    {
+      Utils.Logger.debug (this, "DataSink died...");
+    }
+
+    private DataSinkConfiguration config;
+    private Gee.Set<ItemProvider> item_plugins;
+    private Gee.Set<ActionProvider> action_plugins;
+    private uint query_id;
+    // data sink will keep reference to the name cache, so others will get this
+    // instance on call to get_default()
+    private DBusService dbus_name_cache;
+    private DesktopFileService desktop_file_service;
+    private PluginRegistry registry;
+    private RelevancyService relevancy_service;
+    private VolumeService volume_service;
+    private Type[] plugin_types;
+
+    construct
+    {
+      item_plugins = new Gee.HashSet<ItemProvider> ();
+      action_plugins = new Gee.HashSet<ActionProvider> ();
+      plugin_types = {};
+      query_id = 0;
+
+      var cfg = ConfigService.get_default ();
+      config = (DataSinkConfiguration)
+        cfg.get_config ("data-sink", "global", typeof (DataSinkConfiguration));
+
+      // oh well, yea we need a few singletons
+      registry = PluginRegistry.get_default ();
+      relevancy_service = RelevancyService.get_default ();
+      volume_service = VolumeService.get_default ();
+
+      initialize_caches.begin ();
+      register_static_plugin (typeof (CommonActions));
+    }
+
+    private async void initialize_caches ()
+    {
+      Idle.add_full (Priority.LOW, initialize_caches.callback);
+      yield;
+
+      int initialized_components = 0;
+      int NUM_COMPONENTS = 2;
+
+      dbus_name_cache = DBusService.get_default ();
+      dbus_name_cache.initialize.begin (() =>
+      {
+        initialized_components++;
+        if (initialized_components >= NUM_COMPONENTS)
+        {
+          initialize_caches.callback ();
+        }
+      });
+
+      desktop_file_service = DesktopFileService.get_default ();
+      desktop_file_service.reload_done.connect (this.check_plugins);
+      desktop_file_service.initialize.begin (() =>
+      {
+        initialized_components++;
+        if (initialized_components >= NUM_COMPONENTS)
+        {
+          initialize_caches.callback ();
+        }
+      });
+
+      yield;
+
+      Idle.add (() => { this.load_plugins (); return false; });
+    }
+    
+    private void check_plugins ()
+    {
+      PluginRegisterFunc[] reg_funcs = {};
+      foreach (var pi in registry.get_plugins ())
+      {
+        reg_funcs += pi.register_func;
+      }
+
+      foreach (PluginRegisterFunc func in reg_funcs)
+      {
+        func ();
+      }
+    }
+
+    public bool has_empty_handlers { get; set; default = false; }
+    public bool has_unknown_handlers { get; set; default = false; }
+
+    private bool plugins_loaded = false;
+
+    public signal void plugin_registered (Object plugin);
+
+    protected void register_plugin (Object plugin)
+    {
+      if (plugin is ActionProvider)
+      {
+        ActionProvider action_plugin = plugin as ActionProvider;
+        action_plugins.add (action_plugin);
+        has_unknown_handlers |= action_plugin.handles_unknown ();
+      }
+      if (plugin is ItemProvider)
+      {
+        ItemProvider item_plugin = plugin as ItemProvider;
+        item_plugins.add (item_plugin);
+        has_empty_handlers |= item_plugin.handles_empty_query ();
+      }
+
+      plugin_registered (plugin);
+    }
+    
+    private void update_has_unknown_handlers ()
+    {
+      bool tmp = false;
+      foreach (var action in action_plugins)
+      {
+        if (action.enabled && action.handles_unknown ())
+        {
+          tmp = true;
+          break;
+        }
+      }
+      has_unknown_handlers = tmp;
+    }
+
+    private void update_has_empty_handlers ()
+    {
+      bool tmp = false;
+      foreach (var item_plugin in item_plugins)
+      {
+        if (item_plugin.enabled && item_plugin.handles_empty_query ())
+        {
+          tmp = true;
+          break;
+        }
+      }
+      has_empty_handlers = tmp;
+    }
+
+    private Object? create_plugin (Type t)
+    {
+      var obj_class = (ObjectClass) t.class_ref ();
+      if (obj_class != null && obj_class.find_property ("data-sink") != null)
+      {
+        return Object.new (t, "data-sink", this, null);
+      }
+      else
+      {
+        return Object.new (t, null);
+      }
+    }
+
+    private void load_plugins ()
+    {
+      // FIXME: fetch and load modules
+      foreach (Type t in plugin_types)
+      {
+        t.class_ref (); // makes the plugin register itself into PluginRegistry
+        PluginRegistry.PluginInfo? info = registry.get_plugin_info_for_type (t);
+        bool skip = info != null && info.runnable == false;
+        if (config.is_plugin_enabled (t) && !skip)
+        {
+          var plugin = create_plugin (t);
+          register_plugin (plugin);
+          (plugin as Activatable).activate ();
+        }
+      }
+
+      plugins_loaded = true;
+    }
+    
+    /* This needs to be called right after instantiation,
+     * if plugins_loaded == true, it won't have any effect. */
+    public void register_static_plugin (Type plugin_type)
+    {
+      if (plugin_type in plugin_types) return;
+      plugin_types += plugin_type;
+    }
+    
+    public unowned Object? get_plugin (string name)
+    {
+      unowned Object? result = null;
+
+      foreach (var plugin in item_plugins)
+      {
+        if (plugin.get_type ().name () == name)
+        {
+          result = plugin;
+          break;
+        }
+      }
+
+      return result;
+    }
+    
+    public bool is_plugin_enabled (Type plugin_type)
+    {
+      foreach (var plugin in item_plugins)
+      {
+        if (plugin.get_type () == plugin_type) return plugin.enabled;
+      }
+      
+      foreach (var action in action_plugins)
+      {
+        if (action.get_type () == plugin_type) return action.enabled;
+      }
+      
+      return false;
+    }
+    
+    public void set_plugin_enabled (Type plugin_type, bool enabled)
+    {
+      // save it into our config object
+      config.set_plugin_enabled (plugin_type, enabled);
+      ConfigService.get_default ().set_config ("data-sink", "global", config);
+
+      foreach (var plugin in item_plugins)
+      {
+        if (plugin.get_type () == plugin_type)
+        {
+          plugin.enabled = enabled;
+          if (enabled) plugin.activate ();
+          else plugin.deactivate ();
+          update_has_empty_handlers ();
+          return;
+        }
+      }
+
+      foreach (var action in action_plugins)
+      {
+        if (action.get_type () == plugin_type)
+        {
+          action.enabled = enabled;
+          if (enabled) action.activate ();
+          else action.deactivate ();
+          update_has_unknown_handlers ();
+          return;
+        }
+      }
+
+      // plugin isn't instantiated yet
+      if (enabled)
+      {
+        var new_instance = create_plugin (plugin_type);
+        register_plugin (new_instance);
+        (new_instance as Activatable).activate ();
+      }
+    }
+
+    [Signal (detailed = true)]
+    public signal void search_done (ResultSet rs, uint query_id);
+
+    public async Gee.List<Match> search (string query,
+                                         QueryFlags flags,
+                                         ResultSet? dest_result_set,
+                                         Cancellable? cancellable = null) throws SearchError
+    {
+      // wait for our initialization
+      while (!plugins_loaded)
+      {
+        Timeout.add (100, search.callback);
+        yield;
+        if (cancellable != null && cancellable.is_cancelled ())
+        {
+          throw new SearchError.SEARCH_CANCELLED ("Cancelled");
+        }
+      }
+      var q = Query (query_id++, query, flags);
+      string query_stripped = query.strip ();
+
+      var cancellables = new GLib.List<Cancellable> ();
+
+      var current_result_set = dest_result_set ?? new ResultSet ();
+      int search_size = item_plugins.size;
+      // FIXME: this is probably useless, if async method finishes immediately,
+      // it'll call complete_in_idle
+      bool waiting = false;
+
+      foreach (var data_plugin in item_plugins)
+      {
+        bool skip = !data_plugin.enabled ||
+          (query == "" && !data_plugin.handles_empty_query ()) ||
+          !data_plugin.handles_query (q);
+        if (skip)
+        {
+          search_size--;
+          continue;
+        }
+        // we need to pass separate cancellable to each plugin, because we're
+        // running them in parallel
+        var c = new Cancellable ();
+        cancellables.prepend (c);
+        q.cancellable = c;
+        // magic comes here
+        data_plugin.search.begin (q, (src_obj, res) =>
+        {
+          var plugin = src_obj as ItemProvider;
+          try
+          {
+            var results = plugin.search.end (res);
+            this.search_done[plugin.get_type ().name ()] (results, q.query_id);
+            current_result_set.add_all (results);
+          }
+          catch (SearchError err)
+          {
+            if (!(err is SearchError.SEARCH_CANCELLED))
+            {
+              warning ("%s returned error: %s",
+                       plugin.get_type ().name (), err.message);
+            }
+          }
+
+          if (--search_size == 0 && waiting) search.callback ();
+        });
+      }
+      cancellables.reverse ();
+      
+      if (cancellable != null)
+      {
+        cancellable.connect (() =>
+        {
+          foreach (var c in cancellables) c.cancel ();
+        });
+      }
+
+      waiting = true;
+      if (search_size > 0) yield;
+
+      if (cancellable != null && cancellable.is_cancelled ())
+      {
+        throw new SearchError.SEARCH_CANCELLED ("Cancelled");
+      }
+
+      if (has_unknown_handlers && query_stripped != "")
+      {
+        var unknown_match = new DefaultMatch (query);
+        bool add_to_rs = false;
+        if (QueryFlags.ACTIONS in flags || QueryFlags.TEXT in flags)
+        {
+          // FIXME: maybe we should also check here if there are any matches
+          add_to_rs = true;
+        }
+        else
+        {
+          // check whether any of the actions support this category
+          var unknown_match_actions = find_actions_for_unknown_match (unknown_match, flags);
+          if (unknown_match_actions.size > 0) add_to_rs = true;
+        }
+
+        if (add_to_rs) current_result_set.add (unknown_match, 0);
+      }
+
+      return current_result_set.get_sorted_list ();
+    }
+    
+    protected Gee.List<Match> find_actions_for_unknown_match (Match match,
+                                                              QueryFlags flags)
+    {
+      var rs = new ResultSet ();
+      var q = Query (0, "", flags);
+      foreach (var action_plugin in action_plugins)
+      {
+        if (!action_plugin.enabled) continue;
+        if (!action_plugin.handles_unknown ()) continue;
+        rs.add_all (action_plugin.find_for_match (ref q, match));
+      }
+
+      return rs.get_sorted_list ();
+    }
+
+    public Gee.List<Match> find_actions_for_match (Match match, string? query,
+                                                   QueryFlags flags)
+    {
+      var rs = new ResultSet ();
+      var q = Query (0, query ?? "", flags);
+      foreach (var action_plugin in action_plugins)
+      {
+        if (!action_plugin.enabled) continue;
+        rs.add_all (action_plugin.find_for_match (ref q, match));
+      }
+      
+      return rs.get_sorted_list ();
+    }
+  }
+}
+

=== added file 'lib/synapse-core/dbus-service.vala'
--- lib/synapse-core/dbus-service.vala	1970-01-01 00:00:00 +0000
+++ lib/synapse-core/dbus-service.vala	2014-06-16 07:45:32 +0000
@@ -0,0 +1,166 @@
+/*
+ * Copyright (C) 2010 Michal Hruby <[e-mail]>
+ *
+ * This library 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 2.1 of the License, or (at your option) any later version.
+ *
+ * This library 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 <http://www.gnu.org/licenses/>.
+ *
+ * Authored by Michal Hruby <[e-mail]>
+ *
+ */
+
+namespace Synapse
+{
+  [DBus (name = "org.freedesktop.DBus")]
+  public interface FreeDesktopDBus : GLib.Object
+  {
+    public const string UNIQUE_NAME = "org.freedesktop.DBus";
+    public const string OBJECT_PATH = "/org/freedesktop/DBus";
+
+    public abstract async string[] list_queued_owners (string name) throws IOError;
+    public abstract async string[] list_names () throws IOError;
+    public abstract async string[] list_activatable_names () throws IOError;
+    public abstract async bool name_has_owner (string name) throws IOError;
+    public signal void name_owner_changed (string name,
+                                           string old_owner,
+                                           string new_owner);
+    public abstract async uint32 start_service_by_name (string name,
+                                               uint32 flags) throws IOError;
+    public abstract async string get_name_owner (string name) throws IOError;
+  }
+  
+  public class DBusService : Object
+  {
+    private FreeDesktopDBus proxy;
+    private Gee.Set<string> owned_names;
+    private Gee.Set<string> activatable_names;
+    private Gee.Set<string> system_activatable_names;
+    
+    private Utils.AsyncOnce<bool> init_once;
+
+    // singleton that can be easily destroyed
+    public static DBusService get_default ()
+    {
+      return instance ?? new DBusService ();
+    }
+
+    private DBusService ()
+    {
+    }
+    
+    private static unowned DBusService? instance;
+    construct
+    {
+      instance = this;
+      owned_names = new Gee.HashSet<string> ();
+      activatable_names = new Gee.HashSet<string> ();
+      system_activatable_names = new Gee.HashSet<string> ();
+      init_once = new Utils.AsyncOnce<bool> ();
+
+      initialize.begin ();
+    }
+    
+    ~DBusService ()
+    {
+      instance = null;
+    }
+    
+    private void name_owner_changed (FreeDesktopDBus sender,
+                                     string name,
+                                     string old_owner,
+                                     string new_owner)
+    {
+      if (name.has_prefix (":")) return;
+
+      if (old_owner == "")
+      {
+        owned_names.add (name);
+        owner_changed (name, true);
+      }
+      else if (new_owner == "")
+      {
+        owned_names.remove (name);
+        owner_changed (name, false);
+      }
+    }
+    
+    public signal void owner_changed (string name, bool is_owned);
+    
+    public bool name_has_owner (string name)
+    {
+      return name in owned_names;
+    }
+    
+    public bool name_is_activatable (string name)
+    {
+      return name in activatable_names;
+    }
+    
+    public bool service_is_available (string name)
+    {
+      return name in system_activatable_names;
+    }
+
+    public async void initialize ()
+    {
+      if (init_once.is_initialized ()) return;
+      var is_locked = yield init_once.enter ();
+      if (!is_locked) return;
+
+      string[] names;
+      try
+      {
+        proxy = Bus.get_proxy_sync (BusType.SESSION,
+                                    FreeDesktopDBus.UNIQUE_NAME,
+                                    FreeDesktopDBus.OBJECT_PATH);
+
+        proxy.name_owner_changed.connect (this.name_owner_changed);
+        names = yield proxy.list_names ();
+        foreach (unowned string name in names)
+        {
+          if (name.has_prefix (":")) continue;
+          owned_names.add (name);
+        }
+        
+        names = yield proxy.list_activatable_names ();
+        foreach (unowned string session_act in names)
+        {
+          activatable_names.add (session_act);
+        }
+      }
+      catch (Error err)
+      {
+        warning ("%s", err.message);
+      }
+
+      try
+      {
+        FreeDesktopDBus sys_proxy = Bus.get_proxy_sync (
+                                            BusType.SYSTEM,
+                                            FreeDesktopDBus.UNIQUE_NAME,
+                                            FreeDesktopDBus.OBJECT_PATH);
+
+        names = yield sys_proxy.list_activatable_names ();
+        foreach (unowned string system_act in names)
+        {
+          system_activatable_names.add (system_act);
+        }
+      }
+      catch (Error sys_err)
+      {
+        warning ("%s", sys_err.message);
+      }
+      init_once.leave (true);
+    }
+  }
+}
+

=== added file 'lib/synapse-core/desktop-file-service.vala'
--- lib/synapse-core/desktop-file-service.vala	1970-01-01 00:00:00 +0000
+++ lib/synapse-core/desktop-file-service.vala	2014-06-16 07:45:32 +0000
@@ -0,0 +1,635 @@
+/*
+ * Copyright (C) 2010 Michal Hruby <[e-mail]>
+ *
+ * This library 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 2.1 of the License, or (at your option) any later version.
+ *
+ * This library 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 <http://www.gnu.org/licenses/>.
+ *
+ * Authored by Michal Hruby <[e-mail]>
+ *             Alberto Aldegheri <[e-mail]>
+ *
+ */
+
+namespace Synapse
+{
+  errordomain DesktopFileError
+  {
+    UNINTERESTING_ENTRY
+  }
+
+  public class DesktopFileInfo: Object
+  {
+    // registered environments from http://standards.freedesktop.org/menu-spec/latest
+    // (and pantheon)
+    [Flags]
+    public enum EnvironmentType
+    {
+      GNOME     = 1 << 0,
+      KDE       = 1 << 1,
+      LXDE      = 1 << 2,
+      MATE      = 1 << 3,
+      RAZOR     = 1 << 4,
+      ROX       = 1 << 5,
+      TDE       = 1 << 6,
+      UNITY     = 1 << 7,
+      XFCE      = 1 << 8,
+      PANTHEON  = 1 << 9,
+      OLD       = 1 << 10,
+
+      ALL       = 0x3FF
+    }
+   
+    public string desktop_id { get; construct set; } 
+    public string name { get; construct set; }
+    public string comment { get; set; default = ""; }
+    public string icon_name { get; construct set; default = ""; }
+
+    public bool needs_terminal { get; set; default = false; }
+    public string filename { get; construct set; }
+
+    public string exec { get; set; }
+
+    public bool is_hidden { get; private set; default = false; }
+    public bool is_valid { get; private set; default = true; }
+
+    public string[] mime_types = null;
+    
+    private string? name_folded = null;
+    public unowned string get_name_folded ()
+    {
+      if (name_folded == null) name_folded = name.casefold ();
+      return name_folded;
+    }
+    
+    public EnvironmentType show_in { get; set; default = EnvironmentType.ALL; }
+
+    private static const string GROUP = "Desktop Entry";
+
+    public DesktopFileInfo.for_keyfile (string path, KeyFile keyfile,
+                                        string desktop_id)
+    {
+      Object (filename: path, desktop_id: desktop_id);
+
+      init_from_keyfile (keyfile);
+    }
+
+    private EnvironmentType parse_environments (string[] environments)
+    {
+      EnvironmentType result = 0;
+      foreach (unowned string env in environments)
+      {
+        string env_up = env.up ();
+        switch (env_up)
+        {
+          case "GNOME": result |= EnvironmentType.GNOME; break;
+          case "PANTHEON": result |= EnvironmentType.PANTHEON; break;
+          case "KDE": result |= EnvironmentType.KDE; break;
+          case "LXDE": result |= EnvironmentType.LXDE; break;
+          case "MATE": result |= EnvironmentType.MATE; break;
+          case "RAZOR": result |= EnvironmentType.RAZOR; break;
+          case "ROX": result |= EnvironmentType.ROX; break;
+          case "TDE": result |= EnvironmentType.TDE; break;
+          case "UNITY": result |= EnvironmentType.UNITY; break;
+          case "XFCE": result |= EnvironmentType.XFCE; break;
+          case "OLD": result |= EnvironmentType.OLD; break;
+          default: warning ("%s is not understood", env); break;
+        }
+      }
+      return result;
+    }
+
+    private void init_from_keyfile (KeyFile keyfile)
+    {
+      try
+      {
+        if (keyfile.get_string (GROUP, "Type") != "Application")
+        {
+          throw new DesktopFileError.UNINTERESTING_ENTRY ("Not Application-type desktop entry");
+        }
+        
+        if (keyfile.has_key (GROUP, "Categories"))
+        {
+          string[] categories = keyfile.get_string_list (GROUP, "Categories");
+          if ("Screensaver" in categories)
+          {
+            throw new DesktopFileError.UNINTERESTING_ENTRY ("Screensaver desktop entry");
+          }
+        }
+
+        DesktopAppInfo app_info;
+        app_info = new DesktopAppInfo.from_keyfile (keyfile);
+
+        if (app_info == null)
+        {
+          throw new DesktopFileError.UNINTERESTING_ENTRY ("Unable to create AppInfo");
+        }
+
+        name = app_info.get_name ();
+        exec = app_info.get_commandline ();
+        if (exec == null)
+        {
+          throw new DesktopFileError.UNINTERESTING_ENTRY ("Unable to get exec for %s".printf (name));
+        }
+
+        // check for hidden desktop files
+        if (keyfile.has_key (GROUP, "Hidden") &&
+          keyfile.get_boolean (GROUP, "Hidden"))
+        {
+          is_hidden = true;
+        }
+        if (keyfile.has_key (GROUP, "NoDisplay") &&
+          keyfile.get_boolean (GROUP, "NoDisplay"))
+        {
+          is_hidden = true;
+        }
+
+        comment = app_info.get_description () ?? "";
+
+        var icon = app_info.get_icon () ??
+          new ThemedIcon ("application-default-icon");
+        icon_name = icon.to_string ();
+
+        if (keyfile.has_key (GROUP, "MimeType"))
+        {
+          mime_types = keyfile.get_string_list (GROUP, "MimeType");
+        }
+        if (keyfile.has_key (GROUP, "Terminal"))
+        {
+          needs_terminal = keyfile.get_boolean (GROUP, "Terminal");
+        }
+        if (keyfile.has_key (GROUP, "OnlyShowIn"))
+        {
+          show_in = parse_environments (keyfile.get_string_list (GROUP, 
+                                                                 "OnlyShowIn"));
+        }
+        else if (keyfile.has_key (GROUP, "NotShowIn"))
+        {
+          var not_show = parse_environments (keyfile.get_string_list (GROUP,
+                                                                  "NotShowIn"));
+          show_in = EnvironmentType.ALL ^ not_show;
+        }
+        
+        // special case these, people are using them quite often and wonder
+        // why they don't appear
+        if (filename.has_suffix ("gconf-editor.desktop") ||
+            filename.has_suffix ("dconf-editor.desktop"))
+        {
+          is_hidden = false;
+        }
+      }
+      catch (Error err)
+      {
+        Utils.Logger.warning (this, "%s", err.message);
+        is_valid = false;
+      }
+    }
+  }
+
+  public class DesktopFileService : Object
+  {
+    private static unowned DesktopFileService? instance;
+    private Utils.AsyncOnce<bool> init_once;
+
+    // singleton that can be easily destroyed
+    public static DesktopFileService get_default ()
+    {
+      return instance ?? new DesktopFileService ();
+    }
+
+    private DesktopFileService ()
+    {
+    }
+
+    private Gee.List<FileMonitor> directory_monitors;
+    private Gee.List<DesktopFileInfo> all_desktop_files;
+    private Gee.List<DesktopFileInfo> non_hidden_desktop_files;
+    private Gee.Map<unowned string, Gee.List<DesktopFileInfo> > mimetype_map;
+    private Gee.Map<string, Gee.List<DesktopFileInfo> > exec_map;
+    private Gee.Map<string, DesktopFileInfo> desktop_id_map;
+    private Gee.MultiMap<string, string> mimetype_parent_map;
+    
+    construct
+    {
+      instance = this;
+
+      directory_monitors = new Gee.ArrayList<FileMonitor> ();
+      all_desktop_files = new Gee.ArrayList<DesktopFileInfo> ();
+      non_hidden_desktop_files = new Gee.ArrayList<DesktopFileInfo> ();
+      mimetype_parent_map = new Gee.HashMultiMap<string, string> ();
+      init_once = new Utils.AsyncOnce<bool> ();
+
+      initialize.begin ();
+    }
+    
+    ~DesktopFileService ()
+    {
+      instance = null;
+    }
+
+    public async void initialize ()
+    {
+      if (init_once.is_initialized ()) return;
+      var is_locked = yield init_once.enter ();
+      if (!is_locked) return;
+
+      get_environment_type ();
+      DesktopAppInfo.set_desktop_env (session_type_str);
+
+      Idle.add_full (Priority.LOW, initialize.callback);
+      yield;
+
+      yield load_all_desktop_files ();
+
+      init_once.leave (true);
+    }
+    
+    private DesktopFileInfo.EnvironmentType session_type =
+      DesktopFileInfo.EnvironmentType.GNOME;
+    private string session_type_str = "GNOME";
+    
+    public DesktopFileInfo.EnvironmentType get_environment ()
+    {
+      return this.session_type;
+    }
+    
+    private void get_environment_type ()
+    {
+      unowned string? session_var;
+      session_var = Environment.get_variable ("XDG_CURRENT_DESKTOP");
+      if (session_var == null)
+      {
+        session_var = Environment.get_variable ("DESKTOP_SESSION");
+      }
+
+      if (session_var == null) return;
+
+      string session = session_var.down ();
+
+      if (session.has_prefix ("unity") || session.has_prefix ("ubuntu"))
+      {
+        session_type = DesktopFileInfo.EnvironmentType.UNITY;
+        session_type_str = "Unity";
+      }
+      else if (session.has_prefix ("kde"))
+      {
+        session_type = DesktopFileInfo.EnvironmentType.KDE;
+        session_type_str = "KDE";
+      }
+      else if (session.has_prefix ("gnome"))
+      {
+        session_type = DesktopFileInfo.EnvironmentType.GNOME;
+        session_type_str = "GNOME";
+      }
+      else if (session.has_prefix ("lx"))
+      {
+        session_type = DesktopFileInfo.EnvironmentType.LXDE;
+        session_type_str = "LXDE";
+      }
+      else if (session.has_prefix ("xfce"))
+      {
+        session_type = DesktopFileInfo.EnvironmentType.XFCE;
+        session_type_str = "XFCE";
+      }
+      else if (session.has_prefix ("mate"))
+      {
+        session_type = DesktopFileInfo.EnvironmentType.MATE;
+        session_type_str = "MATE";
+      }
+      else if (session.has_prefix ("razor"))
+      {
+        session_type = DesktopFileInfo.EnvironmentType.RAZOR;
+        session_type_str = "Razor";
+      }
+      else if (session.has_prefix ("tde"))
+      {
+        session_type = DesktopFileInfo.EnvironmentType.TDE;
+        session_type_str = "TDE";
+      }
+      else if (session.has_prefix ("rox"))
+      {
+        session_type = DesktopFileInfo.EnvironmentType.ROX;
+        session_type_str = "ROX";
+      }
+      else if (session.has_prefix ("pantheon"))
+      {
+        session_type = DesktopFileInfo.EnvironmentType.PANTHEON;
+        session_type_str = "Pantheon";
+      }
+      else
+      {
+        warning ("Desktop session type is not recognized, assuming GNOME.");
+      }
+    }
+
+    private string? get_cache_file_name (string dir_name)
+    {
+      // FIXME: should we use this? it's Ubuntu-specific
+      string? locale = Intl.setlocale (LocaleCategory.MESSAGES, null);
+      if (locale == null) return null;
+
+      // even though this is what the patch in gnome-menus does, the name 
+      // of the file is different here (utf is uppercase)
+      string filename = "desktop.%s.cache".printf (
+        locale.replace (".UTF-8", ".utf8"));
+
+      return Path.build_filename (dir_name, filename, null);
+    }
+    
+    private async void process_directory (File directory,
+                                          string id_prefix,
+                                          Gee.Set<File> monitored_dirs)
+    {
+      try
+      {
+        string path = directory.get_path ();
+        // we need to skip menu-xdg directory, see lp:686624
+        if (path != null && path.has_suffix ("menu-xdg")) return;
+        // screensavers don't interest us, skip those
+        if (path != null && path.has_suffix ("/screensavers")) return;
+
+        Utils.Logger.debug (this, "Searching for desktop files in: %s", path);
+        bool exists = yield Utils.query_exists_async (directory);
+        if (!exists) return;
+        /* Check if we already scanned this directory // lp:686624 */
+        foreach (var scanned_dir in monitored_dirs)
+        {
+          if (path == scanned_dir.get_path ()) return;
+        }
+        monitored_dirs.add (directory);
+        var enumerator = yield directory.enumerate_children_async (
+          FileAttribute.STANDARD_NAME + "," + FileAttribute.STANDARD_TYPE,
+          0, 0);
+        var files = yield enumerator.next_files_async (1024, 0);
+        foreach (var f in files)
+        {
+          unowned string name = f.get_name ();
+          if (f.get_file_type () == FileType.DIRECTORY)
+          {
+            // FIXME: this could cause too many open files error, or?
+            var subdir = directory.get_child (name);
+            var new_prefix = "%s%s-".printf (id_prefix, subdir.get_basename ());
+            yield process_directory (subdir, new_prefix, monitored_dirs);
+          }
+          else
+          {
+            // ignore ourselves
+            if (name.has_suffix ("synapse.desktop")) continue;
+            if (name.has_suffix (".desktop"))
+            {
+              yield load_desktop_file (directory.get_child (name), id_prefix);
+            }
+          }
+        }
+      }
+      catch (Error err)
+      {
+        warning ("%s", err.message);
+      }
+    }
+
+    private async void load_all_desktop_files ()
+    {
+      string[] data_dirs = Environment.get_system_data_dirs ();
+      data_dirs += Environment.get_user_data_dir ();
+
+      Gee.Set<File> desktop_file_dirs = new Gee.HashSet<File> ();
+
+      mimetype_parent_map.clear ();
+
+      foreach (unowned string data_dir in data_dirs)
+      {
+        string dir_path = Path.build_filename (data_dir, "applications", null);
+        var directory = File.new_for_path (dir_path);
+        yield process_directory (directory, "", desktop_file_dirs);
+        dir_path = Path.build_filename (data_dir, "mime", "subclasses");
+        yield load_mime_parents_from_file (dir_path);
+      }
+      
+      create_indices ();
+
+      directory_monitors = new Gee.ArrayList<FileMonitor> ();
+      foreach (File d in desktop_file_dirs)
+      {
+        try
+        {
+          FileMonitor monitor = d.monitor_directory (0, null);
+          monitor.changed.connect (this.desktop_file_directory_changed);
+          directory_monitors.add (monitor);
+        }
+        catch (Error err)
+        {
+          warning ("Unable to monitor directory: %s", err.message);
+        }
+      }
+    }
+    
+    private uint timer_id = 0;
+
+    public signal void reload_started ();
+    public signal void reload_done ();
+
+    private void desktop_file_directory_changed ()
+    {
+      reload_started ();
+      if (timer_id != 0)
+      {
+        Source.remove (timer_id);
+      }
+      
+      timer_id = Timeout.add (5000, () =>
+      {
+        timer_id = 0;
+        reload_desktop_files.begin ();
+        return false;
+      });
+    }
+    
+    private async void reload_desktop_files ()
+    {
+      debug ("Reloading desktop files...");
+      all_desktop_files.clear ();
+      non_hidden_desktop_files.clear ();
+      yield load_all_desktop_files ();
+
+      reload_done ();
+    }
+
+    private async void load_desktop_file (File file, string id_prefix)
+    {
+      try
+      {
+        uint8[] file_contents;
+        bool success = yield file.load_contents_async (null, out file_contents,
+                                                       null);
+        if (success)
+        {
+          var keyfile = new KeyFile ();
+          keyfile.load_from_data ((string) file_contents,
+                                  file_contents.length, 0);
+
+          var desktop_id = "%s%s".printf (id_prefix, file.get_basename ());
+          var dfi = new DesktopFileInfo.for_keyfile (file.get_path (),
+                                                     keyfile,
+                                                     desktop_id);
+          if (dfi.is_valid)
+          {
+            all_desktop_files.add (dfi);
+            if (!dfi.is_hidden && session_type in dfi.show_in)
+            {
+              non_hidden_desktop_files.add (dfi);
+            }
+          }
+        }
+      }
+      catch (Error err)
+      {
+        warning ("%s", err.message);
+      }
+    }
+    
+    private void create_indices ()
+    {
+      // create mimetype maps
+      mimetype_map =
+        new Gee.HashMap<unowned string, Gee.List<DesktopFileInfo> > ();
+      // and exec map
+      exec_map =
+        new Gee.HashMap<string, Gee.List<DesktopFileInfo> > ();
+      // and desktop id map
+      desktop_id_map =
+        new Gee.HashMap<string, DesktopFileInfo> ();
+
+      Regex exec_re;
+      try
+      {
+        exec_re = new Regex ("%[fFuU]");
+      }
+      catch (Error err)
+      {
+        critical ("%s", err.message);
+        return;
+      }
+
+      foreach (var dfi in all_desktop_files)
+      {
+        string exec = "";
+        try
+        {
+          exec = exec_re.replace_literal (dfi.exec, -1, 0, "");
+        }
+        catch (RegexError err)
+        {
+          Utils.Logger.error (this, "%s", err.message);
+        }
+        exec = exec.strip ();
+        // update exec map
+        Gee.List<DesktopFileInfo>? exec_list = exec_map[exec];
+        if (exec_list == null)
+        {
+          exec_list = new Gee.ArrayList<DesktopFileInfo> ();
+          exec_map[exec] = exec_list;
+        }
+        exec_list.add (dfi);
+
+        // update desktop id map
+        var desktop_id = dfi.desktop_id ?? Path.get_basename (dfi.filename);
+        desktop_id_map[desktop_id] = dfi;
+
+        // update mimetype map
+        if (dfi.is_hidden || dfi.mime_types == null) continue;
+        
+        foreach (unowned string mime_type in dfi.mime_types)
+        {
+          Gee.List<DesktopFileInfo>? list = mimetype_map[mime_type];
+          if (list == null)
+          {
+            list = new Gee.ArrayList<DesktopFileInfo> ();
+            mimetype_map[mime_type] = list;
+          }
+          list.add (dfi);
+        }
+      }
+    }
+
+    private async void load_mime_parents_from_file (string fi)
+    {
+      var file = File.new_for_path (fi);
+      bool exists = yield Utils.query_exists_async (file);
+      if (!exists) return;
+      try
+      {
+        var fis = yield file.read_async (GLib.Priority.DEFAULT);
+        var dis = new DataInputStream (fis);
+        string line = null;
+        string[] mimes = null;
+        int len = 0;
+        // Read lines until end of file (null) is reached
+        do {
+          line = yield dis.read_line_async (GLib.Priority.DEFAULT);
+          if (line == null) break;
+          if (line.has_prefix ("#")) continue; //comment line
+          mimes = line.split (" ");
+          len = (int)GLib.strv_length (mimes);
+          if (len != 2) continue;
+          // cannot be parent of myself!
+          if (mimes[0] == mimes[1]) continue;
+          //debug ("Map %s -> %s", mimes[0], mimes[1]);
+          mimetype_parent_map.set (mimes[0], mimes[1]);
+        } while (true);
+      } catch (GLib.Error err) { /* can't read file */ }
+    }
+    
+    private void add_dfi_for_mime (string mime, Gee.Set<DesktopFileInfo> ret)
+    {
+      var dfis = mimetype_map[mime];
+      if (dfis != null) ret.add_all (dfis);
+
+      var parents = mimetype_parent_map[mime];
+      if (parents == null) return;
+      foreach (string parent in parents)
+        add_dfi_for_mime (parent, ret);
+    }
+
+    // retuns desktop files available on the system (without hidden ones)
+    public Gee.List<DesktopFileInfo> get_desktop_files ()
+    {
+      return non_hidden_desktop_files.read_only_view;
+    }
+    
+    // returns all desktop files available on the system (even the ones which
+    // are hidden by default)
+    public Gee.List<DesktopFileInfo> get_all_desktop_files ()
+    {
+      return all_desktop_files.read_only_view;
+    }
+    
+    public Gee.List<DesktopFileInfo> get_desktop_files_for_type (string mime_type)
+    {
+      var dfi_set = new Gee.HashSet<DesktopFileInfo> ();
+      add_dfi_for_mime (mime_type, dfi_set);
+      var ret = new Gee.ArrayList<DesktopFileInfo> ();
+      ret.add_all (dfi_set);
+      return ret;
+    }
+
+    public Gee.List<DesktopFileInfo> get_desktop_files_for_exec (string exec)
+    {
+      return exec_map[exec] ?? new Gee.ArrayList<DesktopFileInfo> ();
+    }
+    
+    public DesktopFileInfo? get_desktop_file_for_id (string desktop_id)
+    {
+      return desktop_id_map[desktop_id];
+    }
+  }
+}
+

=== added file 'lib/synapse-core/match.vala'
--- lib/synapse-core/match.vala	1970-01-01 00:00:00 +0000
+++ lib/synapse-core/match.vala	2014-06-16 07:45:32 +0000
@@ -0,0 +1,144 @@
+/*
+ * Copyright (C) 2010 Michal Hruby <[e-mail]>
+ *
+ * This library 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 2.1 of the License, or (at your option) any later version.
+ *
+ * This library 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 <http://www.gnu.org/licenses/>.
+ *
+ * Authored by Michal Hruby <[e-mail]>
+ *             Alberto Aldegheri <[e-mail]>
+ */
+
+namespace Synapse
+{
+  public enum MatchType
+  {
+    UNKNOWN = 0,
+    TEXT,
+    APPLICATION,
+    GENERIC_URI,
+    ACTION,
+    SEARCH,
+    CONTACT
+  }
+
+  public interface Match: Object
+  {
+    public enum Score
+    {
+      INCREMENT_MINOR = 2000,
+      INCREMENT_SMALL = 5000,
+      INCREMENT_MEDIUM = 10000,
+      INCREMENT_LARGE = 20000,
+      URI_PENALTY = 15000,
+
+      POOR = 50000,
+      BELOW_AVERAGE = 60000,
+      AVERAGE = 70000,
+      ABOVE_AVERAGE = 75000,
+      GOOD = 80000,
+      VERY_GOOD = 85000,
+      EXCELLENT = 90000,
+
+      HIGHEST = 100000
+    }
+    
+    // properties
+    public abstract string title { get; construct set; }
+    public abstract string description { get; set; }
+    public abstract string icon_name { get; construct set; }
+    public abstract bool has_thumbnail { get; construct set; }
+    public abstract string thumbnail_path { get; construct set; }
+    public abstract MatchType match_type { get; construct set; }
+
+    public virtual void execute (Match? match)
+    {
+      Utils.Logger.error (this, "execute () is not implemented");
+    }
+    
+    public virtual void execute_with_target (Match? source, Match? target = null)
+    {
+      if (target == null) execute (source);
+      else Utils.Logger.error (this, "execute () is not implemented");
+    }
+    
+    public virtual bool needs_target () {
+      return false;
+    }
+    
+    public virtual QueryFlags target_flags ()
+    {
+      return QueryFlags.ALL;
+    }
+    
+    public signal void executed ();
+  }
+  
+  public interface ApplicationMatch: Match
+  {
+    public abstract AppInfo? app_info { get; set; }
+    public abstract bool needs_terminal { get; set; }
+    public abstract string? filename { get; construct set; }
+  }
+
+  public interface UriMatch: Match
+  {
+    public abstract string uri { get; set; }
+    public abstract QueryFlags file_type { get; set; }
+    public abstract string mime_type { get; set; }
+  }
+  
+  public interface ContactMatch: Match
+  {
+    public abstract void send_message (string message, bool present);
+    public abstract void open_chat ();
+  }
+
+  public interface ExtendedInfo: Match
+  {
+    public abstract string? extended_info { get; set; }
+  }
+  
+  public enum TextOrigin
+  {
+    UNKNOWN,
+    CLIPBOARD
+  }
+  
+  public interface TextMatch: Match
+  {
+    public abstract TextOrigin text_origin { get; set; }
+    public abstract string get_text ();
+  }
+  
+  public interface SearchMatch: Match, SearchProvider
+  {
+    public abstract Match search_source { get; set; }
+  }
+
+  public class DefaultMatch: Object, Match
+  {
+    public string title { get; construct set; }
+    public string description { get; set; }
+    public string icon_name { get; construct set; }
+    public bool has_thumbnail { get; construct set; }
+    public string thumbnail_path { get; construct set; }
+    public MatchType match_type { get; construct set; }
+    
+    public DefaultMatch (string query_string)
+    {
+      Object (title: query_string, description: "", has_thumbnail: false,
+              icon_name: "unknown", match_type: MatchType.UNKNOWN);
+    }
+  }
+}
+

=== added file 'lib/synapse-core/plugin.vala'
--- lib/synapse-core/plugin.vala	1970-01-01 00:00:00 +0000
+++ lib/synapse-core/plugin.vala	2014-06-16 07:45:32 +0000
@@ -0,0 +1,59 @@
+/*
+ * Copyright (C) 2010 Michal Hruby <[e-mail]>
+ *
+ * This library 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 2.1 of the License, or (at your option) any later version.
+ *
+ * This library 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 <http://www.gnu.org/licenses/>.
+ *
+ * Authored by Michal Hruby <[e-mail]>
+ *
+ */
+
+namespace Synapse
+{
+  public interface Activatable : Object
+  {
+    // this property will eventually go away
+    public abstract bool enabled { get; set; default = true; }
+
+    public abstract void activate ();
+    public abstract void deactivate ();
+  }
+
+  public interface Configurable : Object
+  {
+    public abstract Gtk.Widget create_config_widget ();
+  }
+
+  public interface ItemProvider : Activatable
+  {
+    public abstract async ResultSet? search (Query query) throws SearchError;
+    public virtual bool handles_query (Query query)
+    {
+      return true;
+    }
+    public virtual bool handles_empty_query ()
+    {
+      return false;
+    }
+  }
+
+  public interface ActionProvider : Activatable
+  {
+    public abstract ResultSet? find_for_match (ref Query query, Match match);
+    public virtual bool handles_unknown ()
+    {
+      return false;
+    }
+  }
+}
+

=== added file 'lib/synapse-core/query.vala'
--- lib/synapse-core/query.vala	1970-01-01 00:00:00 +0000
+++ lib/synapse-core/query.vala	2014-06-16 07:45:32 +0000
@@ -0,0 +1,296 @@
+/*
+ * Copyright (C) 2010 Michal Hruby <[e-mail]>
+ *
+ * This library 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 2.1 of the License, or (at your option) any later version.
+ *
+ * This library 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 <http://www.gnu.org/licenses/>.
+ *
+ * Authored by Michal Hruby <[e-mail]>
+ *
+ */
+
+namespace Synapse
+{
+  [Flags]
+  public enum QueryFlags
+  {
+    /* HowTo create categories (32bit).
+     * Authored by Alberto Aldegheri <[e-mail]>
+     * Categories are "stored" in 3 Levels:
+     *  Super-Category
+     *  -> Category
+     *  ----> Sub-Category
+     * ------------------------------------
+     * if (Super-Category does NOT have childs):
+     *    SUPER = 1 << FreeBitPosition
+     * else:
+     *    if (Category does NOT have childs)
+     *      CATEGORY = 1 << FreeBitPosition
+     *    else
+     *      SUB = 1 << FreeBitPosition
+     *      CATEGORY = OR ([subcategories, ...]);
+     *
+     *    SUPER = OR ([categories, ...]);
+     *
+     *
+     * Remember: 
+     *   if you add or remove a category, 
+     *   change labels in UIInterface.CategoryConfig.init_labels
+     *
+     */
+    INCLUDE_REMOTE  = 1 << 0,
+    UNCATEGORIZED   = 1 << 1,
+
+    APPLICATIONS    = 1 << 2,
+    
+    ACTIONS         = 1 << 3,
+    
+      AUDIO           = 1 << 4,
+      VIDEO           = 1 << 5,
+      DOCUMENTS       = 1 << 6,
+      IMAGES          = 1 << 7,
+    FILES           = AUDIO | VIDEO | DOCUMENTS | IMAGES,
+    
+    PLACES          = 1 << 8,
+
+    // FIXME: shouldn't this be FILES | INCLUDE_REMOTE?
+    INTERNET        = 1 << 9,
+    
+    // FIXME: Text Query flag? kinda weird, why do we have this here?
+    TEXT            = 1 << 10,
+    
+    CONTACTS        = 1 << 11,
+
+    ALL           = 0xFFFFFFFF,
+    LOCAL_CONTENT = ALL ^ QueryFlags.INCLUDE_REMOTE
+  }
+  
+  [Flags]
+  public enum MatcherFlags
+  {
+    NO_REVERSED   = 1 << 0,
+    NO_SUBSTRING  = 1 << 1,
+    NO_PARTIAL    = 1 << 2,
+    NO_FUZZY      = 1 << 3
+  }
+
+  public struct Query
+  {
+    string query_string;
+    string query_string_folded;
+    Cancellable cancellable;
+    QueryFlags query_type;
+    uint max_results;
+    uint query_id;
+
+    public Query (uint query_id,
+                  string query,
+                  QueryFlags flags = QueryFlags.LOCAL_CONTENT,
+                  uint num_results = 96)
+    {
+      this.query_id = query_id;
+      this.query_string = query;
+      this.query_string_folded = query.casefold ();
+      this.query_type = flags;
+      this.max_results = num_results;
+    }
+
+    public bool is_cancelled ()
+    {
+      return cancellable.is_cancelled ();
+    }
+
+    public void check_cancellable () throws SearchError
+    {
+      if (cancellable.is_cancelled ())
+      {
+        throw new SearchError.SEARCH_CANCELLED ("Cancelled");
+      }
+    }
+
+    public static Gee.List<Gee.Map.Entry<Regex, int>>
+    get_matchers_for_query (string query,
+                            MatcherFlags match_flags = 0,
+                            RegexCompileFlags flags = GLib.RegexCompileFlags.OPTIMIZE)
+    {
+      /* create a couple of regexes and try to help with matching
+       * match with these regular expressions (with descending score):
+       * 1) ^query$
+       * 2) ^query
+       * 3) \bquery
+       * 4) split to words and seach \bword1.+\bword2 (if there are 2+ words)
+       * 5) query
+       * 6) split to characters and search \bq.+\bu.+\be.+\br.+\by
+       * 7) split to characters and search \bq.*u.*e.*r.*y
+       *
+       * The set of returned regular expressions depends on MatcherFlags.
+       */
+
+      var results = new Gee.HashMap<Regex, int> ();
+      Regex re;
+
+      try
+      {
+        re = new Regex ("^(%s)$".printf (Regex.escape_string (query)), flags);
+        results[re] = Match.Score.HIGHEST;
+      }
+      catch (RegexError err)
+      {
+      }
+
+      try
+      {
+        re = new Regex ("^(%s)".printf (Regex.escape_string (query)), flags);
+        results[re] = Match.Score.EXCELLENT;
+      }
+      catch (RegexError err)
+      {
+      }
+
+      try
+      {
+        re = new Regex ("\\b(%s)".printf (Regex.escape_string (query)), flags);
+        results[re] = Match.Score.VERY_GOOD;
+      }
+      catch (RegexError err)
+      {
+      }
+
+      // split to individual chars
+      string[] individual_words = Regex.split_simple ("\\s+", query.strip ());
+      if (individual_words.length >= 2)
+      {
+        string[] escaped_words = {};
+        foreach (unowned string word in individual_words)
+        {
+          escaped_words += Regex.escape_string (word);
+        }
+        string pattern = "\\b(%s)".printf (string.joinv (").+\\b(",
+                                                         escaped_words));
+
+        try
+        {
+          re = new Regex (pattern, flags);
+          results[re] = Match.Score.GOOD;
+        }
+        catch (RegexError err)
+        {
+        }
+
+        // FIXME: do something generic here
+        if (!(MatcherFlags.NO_REVERSED in match_flags))
+        {
+          if (escaped_words.length == 2)
+          {
+            var reversed = "\\b(%s)".printf (string.join (").+\\b(",
+                                                        escaped_words[1],
+                                                        escaped_words[0],
+                                                        null));
+            try
+            {
+              re = new Regex (reversed, flags);
+              results[re] = Match.Score.GOOD - Match.Score.INCREMENT_MINOR;
+            }
+            catch (RegexError err)
+            {
+            }
+          }
+          else
+          {
+            // not too nice, but is quite fast to compute
+            var orred = "\\b((?:%s))".printf (string.joinv (")|(?:", escaped_words));
+            var any_order = "";
+            for (int i=0; i<escaped_words.length; i++)
+            {
+              bool is_last = i == escaped_words.length - 1;
+              any_order += orred;
+              if (!is_last) any_order += ".+";
+            }
+            try
+            {
+              re = new Regex (any_order, flags);
+              results[re] = Match.Score.AVERAGE + Match.Score.INCREMENT_MINOR;
+            }
+            catch (RegexError err)
+            {
+            }
+          }
+        }
+      }
+      
+      if (!(MatcherFlags.NO_SUBSTRING in match_flags))
+      {
+        try
+        {
+          re = new Regex ("(%s)".printf (Regex.escape_string (query)), flags);
+          results[re] = Match.Score.BELOW_AVERAGE;
+        }
+        catch (RegexError err)
+        {
+        }
+      }
+
+      // split to individual characters
+      string[] individual_chars = Regex.split_simple ("\\s*", query);
+      string[] escaped_chars = {};
+      foreach (unowned string word in individual_chars)
+      {
+        escaped_chars += Regex.escape_string (word);
+      }
+
+      // make  "aj" match "Activity Journal"
+      if (!(MatcherFlags.NO_PARTIAL in match_flags) &&
+          individual_words.length == 1 && individual_chars.length <= 5)
+      {
+        string pattern = "\\b(%s)".printf (string.joinv (").+\\b(",
+                                                         escaped_chars));
+        try
+        {
+          re = new Regex (pattern, flags);
+          results[re] = Match.Score.ABOVE_AVERAGE;
+        }
+        catch (RegexError err)
+        {
+        }
+      }
+
+      if (!(MatcherFlags.NO_FUZZY in match_flags) && escaped_chars.length > 0)
+      {
+        string pattern = "\\b(%s)".printf (string.joinv (").*(",
+                                                         escaped_chars));
+        try
+        {
+          re = new Regex (pattern, flags);
+          results[re] = Match.Score.POOR;
+        }
+        catch (RegexError err)
+        {
+        }
+      }
+
+      var sorted_results = new Gee.ArrayList<Gee.Map.Entry<Regex, int>> ();
+      var entries = results.entries;
+      // FIXME: why it doesn't work without this?
+      sorted_results.set_data ("entries-ref", entries);
+      sorted_results.add_all (entries);
+      sorted_results.sort ((a, b) =>
+      {
+        unowned Gee.Map.Entry<Regex, int> e1 = (Gee.Map.Entry<Regex, int>) a;
+        unowned Gee.Map.Entry<Regex, int> e2 = (Gee.Map.Entry<Regex, int>) b;
+        return e2.value - e1.value;
+      });
+
+      return sorted_results;
+    }
+  }
+}
+

=== added file 'lib/synapse-core/relevancy-backend-zg.vala'
--- lib/synapse-core/relevancy-backend-zg.vala	1970-01-01 00:00:00 +0000
+++ lib/synapse-core/relevancy-backend-zg.vala	2014-06-16 07:45:32 +0000
@@ -0,0 +1,308 @@
+/*
+ * Copyright (C) 2010 Michal Hruby <[e-mail]>
+ *
+ * This library 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 2.1 of the License, or (at your option) any later version.
+ *
+ * This library 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 <http://www.gnu.org/licenses/>.
+ *
+ * Authored by Michal Hruby <[e-mail]>
+ *
+ */
+
+namespace Synapse
+{
+  private class ZeitgeistRelevancyBackend: Object, RelevancyBackend
+  {
+    private Zeitgeist.Log zg_log;
+    private Zeitgeist.DataSourceRegistry zg_dsr;
+    private Gee.Map<string, int> application_popularity;
+    private Gee.Map<string, int> uri_popularity;
+    private bool has_datahub_gio_module = false;
+
+    private const float MULTIPLIER = 65535.0f;
+
+    construct
+    {
+      zg_log = new Zeitgeist.Log ();
+      application_popularity = new Gee.HashMap<string, int> ();
+      uri_popularity = new Gee.HashMap<string, int> ();
+
+      refresh_popularity ();
+      check_data_sources.begin ();
+
+      Timeout.add_seconds (60*30, refresh_popularity);
+    }
+
+    private async void check_data_sources ()
+    {
+      zg_dsr = new Zeitgeist.DataSourceRegistry ();
+      try
+      {
+        var ptr_arr = yield zg_dsr.get_data_sources (null);
+
+        for (uint i=0; i < ptr_arr.len; i++)
+        {
+          unowned Zeitgeist.DataSource ds;
+          ds = (Zeitgeist.DataSource) ptr_arr.index (i);
+          if (ds.get_unique_id () == "com.zeitgeist-project,datahub,gio-launch-listener"
+              && ds.is_enabled ())
+          {
+            has_datahub_gio_module = true;
+            break;
+          }
+        }
+      }
+      catch (Error err)
+      {
+        warning ("Unable to check Zeitgeist data sources: %s", err.message);
+      }
+    }
+
+    private bool refresh_popularity ()
+    {
+      load_application_relevancies.begin ();
+      load_uri_relevancies.begin ();
+      return true;
+    }
+
+    private async void load_application_relevancies ()
+    {
+      Idle.add (load_application_relevancies.callback, Priority.LOW);
+      yield;
+
+      int64 end = Zeitgeist.Timestamp.now ();
+      int64 start = end - Zeitgeist.Timestamp.WEEK * 4;
+      Zeitgeist.TimeRange tr = new Zeitgeist.TimeRange (start, end);
+
+      var event = new Zeitgeist.Event ();
+      event.set_interpretation ("!" + Zeitgeist.ZG_LEAVE_EVENT);
+      var subject = new Zeitgeist.Subject ();
+      subject.set_interpretation (Zeitgeist.NFO_SOFTWARE);
+      subject.set_uri ("application://*");
+      event.add_subject (subject);
+
+      var ptr_arr = new PtrArray ();
+      ptr_arr.add (event);
+
+      Zeitgeist.ResultSet rs;
+
+      try
+      {
+        rs = yield zg_log.find_events (tr, (owned) ptr_arr,
+                                       Zeitgeist.StorageState.ANY,
+                                       256,
+                                       Zeitgeist.ResultType.MOST_POPULAR_SUBJECTS,
+                                       null);
+
+        application_popularity.clear ();
+        uint size = rs.size ();
+        uint index = 0;
+
+        // Zeitgeist (0.6) doesn't have any stats API, so let's approximate
+
+        foreach (Zeitgeist.Event e in rs)
+        {
+          if (e.num_subjects () <= 0) continue;
+          Zeitgeist.Subject s = e.get_subject (0);
+
+          float power = index / (size * 2) + 0.5f; // linearly <0.5, 1.0>
+          float relevancy = 1.0f / Math.powf (index + 1, power);
+          application_popularity[s.get_uri ()] = (int)(relevancy * MULTIPLIER);
+
+          index++;
+        }
+      }
+      catch (Error err)
+      {
+        warning ("%s", err.message);
+        return;
+      }
+    }
+
+    private async void load_uri_relevancies ()
+    {
+      Idle.add (load_uri_relevancies.callback, Priority.LOW);
+      yield;
+
+      int64 end = Zeitgeist.Timestamp.now ();
+      int64 start = end - Zeitgeist.Timestamp.WEEK * 4;
+      Zeitgeist.TimeRange tr = new Zeitgeist.TimeRange (start, end);
+
+      var event = new Zeitgeist.Event ();
+      event.set_interpretation ("!" + Zeitgeist.ZG_LEAVE_EVENT);
+      var subject = new Zeitgeist.Subject ();
+      subject.set_interpretation ("!" + Zeitgeist.NFO_SOFTWARE);
+      subject.set_uri ("file://*");
+      event.add_subject (subject);
+
+      var ptr_arr = new PtrArray ();
+      ptr_arr.add (event);
+
+      Zeitgeist.ResultSet rs;
+      Gee.Map<string, int> popularity_map = new Gee.HashMap<string, int> ();
+
+      try
+      {
+        uint size, index;
+        float power, relevancy;
+        /* Get popularity for file uris */
+        rs = yield zg_log.find_events (tr, (owned) ptr_arr,
+                                       Zeitgeist.StorageState.ANY,
+                                       256,
+                                       Zeitgeist.ResultType.MOST_POPULAR_SUBJECTS,
+                                       null);
+
+        size = rs.size ();
+        index = 0;
+
+        // Zeitgeist (0.6) doesn't have any stats API, so let's approximate
+
+        foreach (Zeitgeist.Event e1 in rs)
+        {
+          if (e1.num_subjects () <= 0) continue;
+          Zeitgeist.Subject s1 = e1.get_subject (0);
+
+          power = index / (size * 2) + 0.5f; // linearly <0.5, 1.0>
+          relevancy = 1.0f / Math.powf (index + 1, power);
+          popularity_map[s1.get_uri ()] = (int)(relevancy * MULTIPLIER);
+
+          index++;
+        }
+        
+        /* Get popularity for web uris */
+        subject.set_interpretation (Zeitgeist.NFO_WEBSITE);
+        subject.set_uri ("");
+        ptr_arr = new PtrArray ();
+        ptr_arr.add (event);
+
+        rs = yield zg_log.find_events (tr, (owned) ptr_arr,
+                                       Zeitgeist.StorageState.ANY,
+                                       128,
+                                       Zeitgeist.ResultType.MOST_POPULAR_SUBJECTS,
+                                       null);
+
+        size = rs.size ();
+        index = 0;
+
+        // Zeitgeist (0.6) doesn't have any stats API, so let's approximate
+
+        foreach (Zeitgeist.Event e2 in rs)
+        {
+          if (e2.num_subjects () <= 0) continue;
+          Zeitgeist.Subject s2 = e2.get_subject (0);
+
+          power = index / (size * 2) + 0.5f; // linearly <0.5, 1.0>
+          relevancy = 1.0f / Math.powf (index + 1, power);
+          popularity_map[s2.get_uri ()] = (int)(relevancy * MULTIPLIER);
+
+          index++;
+        }
+      }
+      catch (Error err)
+      {
+        warning ("%s", err.message);
+      }
+
+      uri_popularity = popularity_map;
+    }
+    
+    public float get_application_popularity (string desktop_id)
+    {
+      if (application_popularity.has_key (desktop_id))
+      {
+        return application_popularity[desktop_id] / MULTIPLIER;
+      }
+
+      return 0.0f;
+    }
+    
+    public float get_uri_popularity (string uri)
+    {
+      if (uri_popularity.has_key (uri))
+      {
+        return uri_popularity[uri] / MULTIPLIER;
+      }
+
+      return 0.0f;
+    }
+    
+    private void reload_relevancies ()
+    {
+      Idle.add_full (Priority.LOW, () =>
+      {
+        load_application_relevancies.begin ();
+        return false;
+      });
+    }
+    
+    public void application_launched (AppInfo app_info)
+    {
+      // FIXME: get rid of this maverick-specific workaround
+      // detect if the Zeitgeist GIO module is installed
+      Type zg_gio_module = Type.from_name ("GAppLaunchHandlerZeitgeist");
+      // FIXME: perhaps we should check app_info.should_show?
+      //   but user specifically asked to open this, so probably not
+      //   otoh the gio module won't pick it up if it's not should_show
+      if (zg_gio_module != 0)
+      {
+        Utils.Logger.debug (this, "libzg-gio-module detected, not pushing");
+        reload_relevancies ();
+        return;
+      }
+
+      if (has_datahub_gio_module)
+      {
+        reload_relevancies ();
+        return;
+      }
+
+      string app_uri = null;
+      if (app_info.get_id () != null)
+      {
+        app_uri = "application://" + app_info.get_id ();
+      }
+      else if (app_info is DesktopAppInfo)
+      {
+        string? filename = (app_info as DesktopAppInfo).get_filename ();
+        if (filename == null) return;
+        app_uri = "application://" + Path.get_basename (filename);
+      }
+
+      Utils.Logger.debug (this, "launched \"%s\", pushing to ZG", app_uri);
+      push_app_launch (app_uri, app_info.get_display_name ());
+
+      // and refresh
+      reload_relevancies ();
+    }
+
+    private void push_app_launch (string app_uri, string? display_name)
+    {
+      //debug ("pushing launch event: %s [%s]", app_uri, display_name);
+      var event = new Zeitgeist.Event ();
+      var subject = new Zeitgeist.Subject ();
+
+      event.set_actor ("application://synapse.desktop");
+      event.set_interpretation (Zeitgeist.ZG_ACCESS_EVENT);
+      event.set_manifestation (Zeitgeist.ZG_USER_ACTIVITY);
+      event.add_subject (subject);
+
+      subject.set_uri (app_uri);
+      subject.set_interpretation (Zeitgeist.NFO_SOFTWARE);
+      subject.set_manifestation (Zeitgeist.NFO_SOFTWARE_ITEM);
+      subject.set_mimetype ("application/x-desktop");
+      subject.set_text (display_name);
+
+      zg_log.insert_events_no_reply (event, null);
+    }
+  }
+}
+

=== added file 'lib/synapse-core/relevancy-service.vala'
--- lib/synapse-core/relevancy-service.vala	1970-01-01 00:00:00 +0000
+++ lib/synapse-core/relevancy-service.vala	2014-06-16 07:45:32 +0000
@@ -0,0 +1,95 @@
+/*
+ * Copyright (C) 2010 Michal Hruby <[e-mail]>
+ *
+ * This library 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 2.1 of the License, or (at your option) any later version.
+ *
+ * This library 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 <http://www.gnu.org/licenses/>.
+ *
+ * Authored by Michal Hruby <[e-mail]>
+ *
+ */
+
+namespace Synapse
+{
+  public interface RelevancyBackend: Object
+  {
+    public abstract float get_application_popularity (string desktop_id);
+    public abstract float get_uri_popularity (string uri);
+
+    public abstract void application_launched (AppInfo app_info);
+  }
+
+  public class RelevancyService : GLib.Object
+  {
+    // singleton that can be easily destroyed
+    private static unowned RelevancyService? instance;
+    public static RelevancyService get_default ()
+    {
+      return instance ?? new RelevancyService ();
+    }
+
+    private RelevancyService ()
+    {
+    }
+
+    ~RelevancyService ()
+    {
+    }
+
+    construct
+    {
+      instance = this;
+      this.add_weak_pointer (&instance);
+      
+      initialize_relevancy_backend ();
+    }
+    
+    private RelevancyBackend backend;
+    
+    private void initialize_relevancy_backend ()
+    {
+      backend = new ZeitgeistRelevancyBackend ();
+    }
+    
+    public float get_application_popularity (string desktop_id)
+    {
+      if (backend == null) return 0.0f;
+      return backend.get_application_popularity (desktop_id);
+    }
+
+    public float get_uri_popularity (string uri)
+    {
+      if (backend == null) return 0.0f;
+      return backend.get_uri_popularity (uri);
+    }
+    
+    public void application_launched (AppInfo app_info)
+    {
+      Utils.Logger.debug (this, "application launched");
+      if (backend == null) return;
+      backend.application_launched (app_info);
+    }
+
+    public static int compute_relevancy (int base_relevancy, float modifier)
+    {
+      // FIXME: let's experiment here
+      // the other idea is to use base_relevancy * (1.0f + modifier)
+      int relevancy = (int) (base_relevancy + modifier * Match.Score.INCREMENT_LARGE * 2);
+      //int relevancy = base_relevancy + (int) (modifier * Match.Score.HIGHEST);
+      return relevancy;
+      // FIXME: this clamping should be done, but it screws up the popularity
+      //   for very popular items with high match score
+      //return int.min (relevancy, Match.Score.HIGHEST);
+    }
+  }
+}
+

=== added file 'lib/synapse-core/result-set.vala'
--- lib/synapse-core/result-set.vala	1970-01-01 00:00:00 +0000
+++ lib/synapse-core/result-set.vala	2014-06-16 07:45:32 +0000
@@ -0,0 +1,121 @@
+/*
+ * Copyright (C) 2010 Michal Hruby <[e-mail]>
+ *
+ * This library 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 2.1 of the License, or (at your option) any later version.
+ *
+ * This library 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 <http://www.gnu.org/licenses/>.
+ *
+ * Authored by Michal Hruby <[e-mail]>
+ *
+ */
+
+namespace Synapse
+{
+  public class ResultSet : Object, Gee.Traversable<Match>, Gee.Iterable <Gee.Map.Entry <Match, int>>
+  {
+    protected Gee.Map<Match, int> matches;
+    protected Gee.Set<unowned string> uris;
+
+    public ResultSet ()
+    {
+      Object ();
+    }
+
+    construct
+    {
+      matches = new Gee.HashMap<Match, int> ();
+      // Match.uri is not owned, so we can optimize here
+      uris = new Gee.HashSet<unowned string> ();
+    }
+
+    public Type element_type
+    {
+      get { return matches.element_type; }
+    }
+
+    public int size
+    {
+      get { return matches.size; }
+    }
+
+    public Gee.Set<Match> keys
+    {
+      owned get { return matches.keys; }
+    }
+
+    public Gee.Set<Gee.Map.Entry <Match, int>> entries
+    {
+      owned get { return matches.entries; }
+    }
+
+    public Gee.Iterator<Gee.Map.Entry <Match, int>?> iterator ()
+    {
+      return matches.iterator ();
+    }
+
+    public bool foreach (Gee.ForallFunc<Match> func)
+    {
+        return matches.keys.foreach (func);
+    }
+
+    public void add (Match match, int relevancy)
+    {
+      matches.set (match, relevancy);
+
+      if (match is UriMatch)
+      {
+        unowned string uri = (match as UriMatch).uri;
+        if (uri != null && uri != "")
+        {
+          uris.add (uri);
+        }
+      }
+    }
+
+    public void add_all (ResultSet? rs)
+    {
+      if (rs == null) return;
+      matches.set_all (rs.matches);
+      uris.add_all (rs.uris);
+    }
+
+    public bool contains_uri (string uri)
+    {
+      return uri in uris;
+    }
+
+    public Gee.List<Match> get_sorted_list ()
+    {
+      var l = new Gee.ArrayList<Gee.Map.Entry<Match, int>> ();
+      l.add_all (matches.entries);
+
+      l.sort ((a, b) => 
+      {
+        unowned Gee.Map.Entry<Match, int> e1 = (Gee.Map.Entry<Match, int>) a;
+        unowned Gee.Map.Entry<Match, int> e2 = (Gee.Map.Entry<Match, int>) b;
+        int relevancy_delta = e2.value - e1.value;
+        if (relevancy_delta != 0) return relevancy_delta;
+        // FIXME: utf8 compare!
+        else return e1.key.title.ascii_casecmp (e2.key.title);
+      });
+
+      var sorted_list = new Gee.ArrayList<Match> ();
+      foreach (Gee.Map.Entry<Match, int> m in l)
+      {
+        sorted_list.add (m.key);
+      }
+
+      return sorted_list;
+    }
+  }
+}
+

=== added file 'lib/synapse-core/utils.vala'
--- lib/synapse-core/utils.vala	1970-01-01 00:00:00 +0000
+++ lib/synapse-core/utils.vala	2014-06-16 07:45:32 +0000
@@ -0,0 +1,439 @@
+/*
+ * Copyright (C) 2010 Michal Hruby <[e-mail]>
+ *
+ * This library 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 2.1 of the License, or (at your option) any later version.
+ *
+ * This library 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 <http://www.gnu.org/licenses/>.
+ *
+ * Authored by Michal Hruby <[e-mail]>
+ *
+ */
+
+namespace Synapse
+{
+  [CCode (gir_namespace = "SynapseUtils", gir_version = "1.0")]
+  namespace Utils
+  {
+    /* Make sure setlocale was called before calling this function
+     *   (Gtk.init calls it automatically)
+     */
+    public static string? remove_accents (string input)
+    {
+      string? result;
+      unowned string charset;
+      GLib.get_charset (out charset);
+      try
+      {
+        result = GLib.convert (input, input.length,
+                               "US-ASCII//TRANSLIT", charset);
+        // no need to waste cpu cycles if the input is the same
+        if (input == result) return null;
+      }
+      catch (ConvertError err)
+      {
+        result = null;
+      }
+
+      return result;
+    }
+    
+    public static string? remove_last_unichar (string input)
+    {
+      long char_count = input.char_count ();
+
+      int len = input.index_of_nth_char (char_count - 1);
+      return input.substring (0, len);
+    }
+    
+    public static async bool query_exists_async (GLib.File f)
+    {
+      bool exists;
+      try
+      {
+        yield f.query_info_async (FileAttribute.STANDARD_TYPE, 0, 0, null);
+        exists = true;
+      }
+      catch (Error err)
+      {
+        exists = false;
+      }
+
+      return exists;
+    }
+    
+    public string extract_type_name (Type obj_type)
+    {
+      string obj_class = obj_type.name ();
+      if (obj_class.has_prefix ("Synapse")) return obj_class.substring (7);
+      
+      return obj_class;
+    }
+    
+    public class Logger
+    {
+      protected const string RED = "\x1b[31m";
+      protected const string GREEN = "\x1b[32m";
+      protected const string YELLOW = "\x1b[33m";
+      protected const string BLUE = "\x1b[34m";
+      protected const string MAGENTA = "\x1b[35m";
+      protected const string CYAN = "\x1b[36m";
+      protected const string RESET = "\x1b[0m";
+
+      private static bool initialized = false;
+      private static bool show_debug = false;
+
+      private static void log_internal (Object? obj, LogLevelFlags level, string format, va_list args)
+      {
+        if (!initialized) initialize ();
+        string desc = "";
+        if (obj != null)
+        {
+          string obj_class = extract_type_name (obj.get_type ());
+          desc = "%s[%s]%s ".printf (MAGENTA, obj_class, RESET);
+        }
+        logv ("Synapse", level, desc + format, args);
+      }
+      
+      private static void initialize ()
+      {
+        var levels = LogLevelFlags.LEVEL_DEBUG | LogLevelFlags.LEVEL_INFO |
+            LogLevelFlags.LEVEL_WARNING | LogLevelFlags.LEVEL_CRITICAL |
+            LogLevelFlags.LEVEL_ERROR;
+
+        string[] domains = 
+        {
+          "Synapse",
+          "Gtk",
+          "Gdk",
+          "GLib",
+          "GLib-GObject",
+          "Pango",
+          "GdkPixbuf",
+          "GLib-GIO",
+          "GtkHotkey"
+        };
+        foreach (unowned string domain in domains)
+        {
+          Log.set_handler (domain, levels, handler);
+        }
+        Log.set_handler (null, levels, handler);
+
+        show_debug = Environment.get_variable ("SYNAPSE_DEBUG") != null;
+        initialized = true;
+      }
+      
+      public static bool debug_enabled ()
+      {
+        if (!initialized) initialize ();
+        return show_debug;
+      }
+      
+      public static void log (Object? obj, string format, ...)
+      {
+        var args = va_list ();
+        log_internal (obj, LogLevelFlags.LEVEL_INFO, format, args);
+      }
+
+      [Diagnostics]
+      public static void debug (Object? obj, string format, ...)
+      {
+        var args = va_list ();
+        log_internal (obj, LogLevelFlags.LEVEL_DEBUG, format, args);
+      }
+
+      public static void warning (Object? obj, string format, ...)
+      {
+        var args = va_list ();
+        log_internal (obj, LogLevelFlags.LEVEL_WARNING, format, args);
+      }
+
+      public static void error (Object? obj, string format, ...)
+      {
+        var args = va_list ();
+        log_internal (obj, LogLevelFlags.LEVEL_ERROR, format, args);
+      }
+      
+      protected static void handler (string? domain, LogLevelFlags level, string msg)
+      {
+        string header;
+        string domain_str = "";
+        if (domain != null && domain != "Synapse") domain_str = domain + "-";
+        var time_val = TimeVal ();
+        long time_str_len = time_val.tv_usec != 0 ? 15 : 8;
+        string cur_time = time_val.to_iso8601 ().substring (11, time_str_len);
+        if (level == LogLevelFlags.LEVEL_DEBUG)
+        {
+          if (!show_debug && domain_str == "") return;
+          header = @"$(GREEN)[$(cur_time) $(domain_str)Debug]$(RESET)";
+        }
+        else if (level == LogLevelFlags.LEVEL_INFO)
+        {
+          header = @"$(BLUE)[$(cur_time) $(domain_str)Info]$(RESET)";
+        }
+        else if (level == LogLevelFlags.LEVEL_WARNING)
+        {
+          header = @"$(RED)[$(cur_time) $(domain_str)Warning]$(RESET)";
+        }
+        else if (level == LogLevelFlags.LEVEL_CRITICAL || level == LogLevelFlags.LEVEL_ERROR)
+        {
+          header = @"$(RED)[$(cur_time) $(domain_str)Critical]$(RESET)";
+        }
+        else
+        {
+          header = @"$(YELLOW)[$(cur_time)]$(RESET)";
+        }
+
+        stdout.printf ("%s %s\n", header, msg);
+#if 0
+        void* buffer[10];
+        int num = Linux.backtrace (&buffer, 10);
+        string[] symbols = Linux.backtrace_symbols (buffer, num);
+        if (symbols != null)
+        {
+          for (int i = 0; i < num; i++) stdout.printf ("%s\n", symbols[i]);
+        }
+#endif
+      }
+    }
+
+    [Compact]
+    private class DelegateWrapper
+    {
+      public SourceFunc callback;
+
+      public DelegateWrapper (owned SourceFunc cb)
+      {
+        callback = (owned) cb;
+      }
+    }
+    /*
+     * Asynchronous Once.
+     *
+     * Usage:
+     * private AsyncOnce<string> once = new AsyncOnce<string> ();
+     * public async void foo ()
+     * {
+     *   if (!once.is_initialized ()) // not stricly necessary but improves perf
+     *   {
+     *     if (yield once.enter ())
+     *     {
+     *       // this block will be executed only once, but the method
+     *       // is reentrant; it's also recommended to wrap this block
+     *       // in try { } and call once.leave() in finally { }
+     *       // if any of the operations can throw an error
+     *       var s = yield get_the_string ();
+     *       once.leave (s);
+     *     }
+     *   }
+     *   // if control reaches this point the once was initialized
+     *   yield do_something_for_string (once.get_data ());
+     * }
+     */
+    public class AsyncOnce<G>
+    {
+      private enum OperationState
+      {
+        NOT_STARTED,
+        IN_PROGRESS,
+        DONE
+      }
+
+      private G inner;
+
+      private OperationState state;
+      private DelegateWrapper[] callbacks = {};
+
+      public AsyncOnce ()
+      {
+        state = OperationState.NOT_STARTED;
+      }
+
+      public unowned G get_data ()
+      {
+        return inner;
+      }
+
+      public bool is_initialized ()
+      {
+        return state == OperationState.DONE;
+      }
+
+      public async bool enter ()
+      {
+        if (state == OperationState.NOT_STARTED)
+        {
+          state = OperationState.IN_PROGRESS;
+          return true;
+        }
+        else if (state == OperationState.IN_PROGRESS)
+        {
+          yield wait_async ();
+        }
+
+        return false;
+      }
+
+      public void leave (G result)
+      {
+        if (state != OperationState.IN_PROGRESS)
+        {
+          warning ("Incorrect usage of AsyncOnce");
+          return;
+        }
+        state = OperationState.DONE;
+        inner = result;
+        notify_all ();
+      }
+
+      /* Once probably shouldn't have this, but it's useful */
+      public void reset ()
+      {
+        if (state == OperationState.IN_PROGRESS)
+        {
+          warning ("AsyncOnce.reset() cannot be called in the middle of initialization.");
+        }
+        else
+        {
+          state = OperationState.NOT_STARTED;
+          inner = null;
+        }
+      }
+
+      private void notify_all ()
+      {
+        foreach (unowned DelegateWrapper wrapper in callbacks)
+        {
+          wrapper.callback ();
+        }
+        callbacks = {};
+      }
+
+      private async void wait_async ()
+      {
+        callbacks += new DelegateWrapper (wait_async.callback);
+        yield;
+      }
+    }
+
+    public class FileInfo
+    {
+      private static string interesting_attributes;
+      static construct
+      {
+        interesting_attributes =
+          string.join (",", FileAttribute.STANDARD_TYPE,
+                            FileAttribute.STANDARD_IS_HIDDEN,
+                            FileAttribute.STANDARD_IS_BACKUP,
+                            FileAttribute.STANDARD_DISPLAY_NAME,
+                            FileAttribute.STANDARD_ICON,
+                            FileAttribute.STANDARD_FAST_CONTENT_TYPE,
+                            FileAttribute.THUMBNAIL_PATH,
+                            null);
+      }
+
+      public string uri;
+      public string parse_name;
+      public QueryFlags file_type;
+      public UriMatch? match_obj;
+      private bool initialized;
+      private Type match_obj_type;
+
+      public FileInfo (string uri, Type obj_type)
+      {
+        assert (obj_type.is_a (typeof (UriMatch)));
+        this.uri = uri;
+        this.match_obj = null;
+        this.match_obj_type = obj_type;
+        this.initialized = false;
+        this.file_type = QueryFlags.UNCATEGORIZED;
+
+        var f = File.new_for_uri (uri);
+        this.parse_name = f.get_parse_name ();
+      }
+      
+      public bool is_initialized ()
+      {
+        return this.initialized;
+      }
+      
+      public async void initialize ()
+      {
+        initialized = true;
+        var f = File.new_for_uri (uri);
+        try
+        {
+          var fi = yield f.query_info_async (interesting_attributes,
+                                             0, 0, null);
+          if (fi.get_file_type () == FileType.REGULAR &&
+              !fi.get_is_hidden () &&
+              !fi.get_is_backup ())
+          {
+            match_obj = (UriMatch) Object.new (match_obj_type,
+              "thumbnail-path", fi.get_attribute_byte_string (FileAttribute.THUMBNAIL_PATH),
+              "icon-name", fi.get_icon ().to_string (),
+              "uri", uri,
+              "title", fi.get_display_name (),
+              "description", f.get_parse_name (),
+              "match-type", MatchType.GENERIC_URI,
+              null
+            );
+            
+            // let's determine the file type
+            unowned string mime_type = 
+              fi.get_attribute_string (FileAttribute.STANDARD_FAST_CONTENT_TYPE);
+            if (ContentType.is_unknown (mime_type))
+            {
+              file_type = QueryFlags.UNCATEGORIZED;
+            }
+            else if (ContentType.is_a (mime_type, "audio/*"))
+            {
+              file_type = QueryFlags.AUDIO;
+            }
+            else if (ContentType.is_a (mime_type, "video/*"))
+            {
+              file_type = QueryFlags.VIDEO;
+            }
+            else if (ContentType.is_a (mime_type, "image/*"))
+            {
+              file_type = QueryFlags.IMAGES;
+            }
+            else if (ContentType.is_a (mime_type, "text/*"))
+            {
+              file_type = QueryFlags.DOCUMENTS;
+            }
+            // FIXME: this isn't right
+            else if (ContentType.is_a (mime_type, "application/*"))
+            {
+              file_type = QueryFlags.DOCUMENTS;
+            }
+
+            match_obj.file_type = file_type;
+            match_obj.mime_type = mime_type;
+          }
+        }
+        catch (Error err)
+        {
+          warning ("%s", err.message);
+        }
+      }
+      
+      public async bool exists ()
+      {
+        var f = File.new_for_uri (uri);
+        bool result = yield query_exists_async (f);
+        
+        return result;
+      }
+    }
+  }
+}
+

=== added file 'lib/synapse-core/volume-service.vala'
--- lib/synapse-core/volume-service.vala	1970-01-01 00:00:00 +0000
+++ lib/synapse-core/volume-service.vala	2014-06-16 07:45:32 +0000
@@ -0,0 +1,193 @@
+/*
+ * Copyright (C) 2010 Michal Hruby <[e-mail]>
+ *
+ * This library 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 2 of the License, or (at your option) any later version.
+ *
+ * This library 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 <http://www.gnu.org/licenses/>.
+ *
+ * Authored by Michal Hruby <[e-mail]>
+ *
+ */
+
+namespace Synapse
+{
+  public class VolumeService : GLib.Object
+  {
+    // singleton that can be easily destroyed
+    private static unowned VolumeService? instance;
+    public static VolumeService get_default ()
+    {
+      return instance ?? new VolumeService ();
+    }
+
+    private VolumeService ()
+    {
+    }
+
+    ~VolumeService ()
+    {
+      instance = null;
+    }
+
+    private VolumeMonitor vm;
+    private Gee.Map<GLib.Volume, VolumeObject> volumes;
+
+    construct
+    {
+      instance = this;
+
+      volumes = new Gee.HashMap<GLib.Volume, VolumeObject> ();
+      initialize ();
+    }
+
+    protected void initialize ()
+    {
+      vm = VolumeMonitor.get ();
+
+      vm.volume_added.connect ((volume) => 
+      {
+        volumes[volume] = new VolumeObject (volume);
+      });
+      vm.volume_removed.connect ((volume) =>
+      {
+        volumes.unset (volume);
+      });
+      vm.mount_added.connect ((mount) => 
+      {
+        var volume = mount.get_volume ();
+        if (volume == null) return;
+
+        if (volume in volumes.keys) volumes[volume].update_state ();
+      });
+      // FIXME: connect also to other signals?
+
+      var volume_list = vm.get_volumes ();
+      process_volume_list (volume_list);
+    }
+
+    private void process_volume_list (GLib.List<GLib.Volume> volume_list)
+    {
+      foreach (unowned GLib.Volume volume in volume_list)
+      {
+        volumes[volume] = new VolumeObject (volume);
+      }
+    }
+
+    public Gee.Collection<VolumeObject> get_volumes ()
+    {
+      return volumes.values;
+    }
+
+    public string? uri_to_volume_name (string uri, out string? volume_path)
+    {
+      volume_path = null;
+      var g_volumes = volumes.keys;
+
+      var f = File.new_for_uri (uri);
+      // FIXME: cache this somehow
+      foreach (var volume in g_volumes)
+      {
+        File? root = volume.get_activation_root ();
+        if (root == null)
+        {
+          var mount = volume.get_mount ();
+          if (mount == null) continue;
+          root = mount.get_root ();
+        }
+
+        if (f.has_prefix (root))
+        {
+          volume_path = root.get_path ();
+          return volume.get_name ();
+        }
+      }
+
+      return null;
+    }
+
+    public class VolumeObject: Object, Match, UriMatch
+    {
+      public string title { get; construct set; }
+      public string description { get; set; }
+      public string icon_name { get; construct set; }
+      public bool has_thumbnail { get; construct set; }
+      public string thumbnail_path { get; construct set; }
+      public MatchType match_type { get; construct set; }
+
+      // UriMatch
+      public string uri { get; set; }
+      public QueryFlags file_type { get; set; }
+      public string mime_type { get; set; }
+
+      private ulong changed_signal_id;
+
+      private GLib.Volume _volume;
+      public GLib.Volume volume
+      {
+        get { return _volume; }
+        set
+        {
+          _volume = value;
+          title = value.get_name ();
+          description = ""; // FIXME
+          icon_name = value.get_icon ().to_string ();
+          has_thumbnail = false;
+          match_type = value.get_mount () != null ?
+            MatchType.GENERIC_URI : MatchType.ACTION;
+
+          if (match_type == MatchType.GENERIC_URI)
+          {
+            uri = value.get_mount ().get_root ().get_uri ();
+            file_type = QueryFlags.PLACES;
+            mime_type = ""; // FIXME: do we need this?
+          }
+          else
+          {
+            uri = null;
+          }
+
+          if (changed_signal_id == 0)
+          {
+            changed_signal_id = _volume.changed.connect (this.update_state);
+          }
+
+          Utils.Logger.debug (this, "vo[%p]: %s [%s], has_mount: %d, uri: %s", this, title, icon_name, (value.get_mount () != null ? 1 : 0), uri);
+        }
+      }
+
+      public void update_state ()
+      {
+        this.volume = _volume; // call setter again
+      }
+
+      public bool is_mounted ()
+      {
+        return _volume.get_mount () != null;
+      }
+
+      public VolumeObject (GLib.Volume volume)
+      {
+        Object (volume: volume);
+      }
+
+      ~VolumeObject ()
+      {
+        if (changed_signal_id != 0)
+        {
+          SignalHandler.disconnect (_volume, changed_signal_id);
+          changed_signal_id = 0;
+        }
+      }
+    }
+  }
+}
+

=== added directory 'lib/synapse-plugins'
=== added file 'lib/synapse-plugins/CMakeLists.txt'
--- lib/synapse-plugins/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ lib/synapse-plugins/CMakeLists.txt	2014-06-16 07:45:32 +0000
@@ -0,0 +1,46 @@
+set(PLUGINS_LIB_VERSION 0.1)
+set(PLUGINS_LIB_SOVERSION 0)
+set(PLUGINS_LIBRARY_NAME synapse-plugins)
+set(PLUGINS_PKG
+    glib-2.0
+    gio-unix-2.0
+    gee-0.8
+    gtk+-3.0
+)
+
+pkg_check_modules(PLUGINS_DEPS REQUIRED ${PLUGINS_PKG})
+
+set(PLUGINS_SOURCE
+    command-plugin.vala
+    desktop-file-plugin.vala
+)
+
+set(LINK_MODE STATIC)
+
+vala_precompile(PLUGINS_VALA_C ${PLUGINS_LIBRARY_NAME}
+    ${PLUGINS_SOURCE}
+PACKAGES
+    ${PLUGINS_PKG}
+    synapse-core
+OPTIONS
+    --vapidir=${CMAKE_BINARY_DIR}/lib/synapse-core
+GENERATE_VAPI
+    ${PLUGINS_LIBRARY_NAME}
+GENERATE_HEADER
+    ${PLUGINS_LIBRARY_NAME}
+)
+
+add_definitions(${PLUGINS_DEPS_CFLAGS} -include config.h -w)
+link_directories(${PLUGINS_DEPS_LIBRARY_DIRS})
+include_directories(${CMAKE_BINARY_DIR}/lib/synapse-core)
+
+add_library(${PLUGINS_LIBRARY_NAME} STATIC ${PLUGINS_VALA_C})
+
+set_target_properties(${PLUGINS_LIBRARY_NAME} PROPERTIES
+    OUTPUT_NAME ${PLUGINS_LIBRARY_NAME}
+    VERSION ${PLUGINS_LIB_VERSION}
+    SOVERSION ${PLUGINS_LIB_SOVERSION}
+)
+
+target_link_libraries (${PLUGINS_LIBRARY_NAME} ${PLUGINS_DEPS_LIBRARIES} synapse-core)
+

=== added file 'lib/synapse-plugins/command-plugin.vala'
--- lib/synapse-plugins/command-plugin.vala	1970-01-01 00:00:00 +0000
+++ lib/synapse-plugins/command-plugin.vala	2014-06-16 07:45:32 +0000
@@ -0,0 +1,188 @@
+/*
+ * Copyright (C) 2010 Michal Hruby <[e-mail]>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301  USA.
+ *
+ * Authored by Michal Hruby <[e-mail]>
+ *
+ */
+
+namespace Synapse
+{
+  public class CommandPlugin: Object, Activatable, ItemProvider
+  {
+    public bool enabled { get; set; default = true; }
+
+    public void activate ()
+    {
+      
+    }
+
+    public void deactivate ()
+    {
+      
+    }
+
+    private class CommandObject: Object, Match, ApplicationMatch
+    {
+      // for Match interface
+      public string title { get; construct set; }
+      public string description { get; set; default = ""; }
+      public string icon_name { get; construct set; default = ""; }
+      public bool has_thumbnail { get; construct set; default = false; }
+      public string thumbnail_path { get; construct set; }
+      public MatchType match_type { get; construct set; }
+
+      // for ApplicationMatch
+      public AppInfo? app_info { get; set; default = null; }
+      public bool needs_terminal { get; set; default = false; }
+      public string? filename { get; construct set; default = null; }
+      public string command { get; construct set; }
+      
+      public CommandObject (string cmd)
+      {
+        Object (title: _("Execute '%s'").printf (cmd), description: _ ("Run command"), command: cmd,
+                icon_name: "application-x-executable",
+                match_type: MatchType.APPLICATION,
+                needs_terminal: cmd.has_prefix ("sudo "));
+
+        try
+        {
+          app_info = AppInfo.create_from_commandline (cmd, null, 0);
+        }
+        catch (Error err)
+        {
+          warning ("%s", err.message);
+        }
+      }
+    }
+    
+    static void register_plugin ()
+    {
+      DataSink.PluginRegistry.get_default ().register_plugin (
+        typeof (CommandPlugin),
+        "Command Search",
+        _ ("Find and execute arbitrary commands."),
+        "system-run",
+        register_plugin
+      );
+    }
+    
+    static construct
+    {
+      register_plugin ();
+    }
+
+    private Gee.Set<string> past_commands;
+    private Regex split_regex;
+
+    construct
+    {
+      // TODO: load from configuration
+      past_commands = new Gee.HashSet<string> ();
+      try
+      {
+        split_regex = new Regex ("\\s+", RegexCompileFlags.OPTIMIZE);
+      }
+      catch (RegexError err)
+      {
+        critical ("%s", err.message);
+      }
+    }
+    
+    private CommandObject? create_co (string exec)
+    {
+      // ignore results that will be returned by DesktopFilePlugin
+      // and at the same time look for hidden and no-display desktop files,
+      // so we can display their info (title, comment, icon)
+      var dfs = DesktopFileService.get_default ();
+      var df_list = dfs.get_desktop_files_for_exec (exec);
+      DesktopFileInfo? dfi = null;
+      foreach (var df in df_list)
+      {
+        if (!df.is_hidden) return null; // will be handled by App plugin
+        dfi = df;
+      }
+
+      var co = new CommandObject (exec);
+      if (dfi != null)
+      {
+        co.title = dfi.name;
+        if (dfi.comment != "") co.description = dfi.comment;
+        if (dfi.icon_name != null && dfi.icon_name != "") co.icon_name = dfi.icon_name;
+      }
+
+      return co;
+    }
+    
+    private void command_executed (Match match)
+    {
+      CommandObject? co = match as CommandObject;
+      if (co == null) return;
+
+      past_commands.add (co.command);
+    }
+
+    public async ResultSet? search (Query q) throws SearchError
+    {
+      // we only search for applications
+      if (!(QueryFlags.APPLICATIONS in q.query_type)) return null;
+
+      Idle.add (search.callback);
+      yield;
+
+      var result = new ResultSet ();
+
+      string stripped = q.query_string.strip ();
+      if (stripped == "") return null;
+      if (stripped.has_prefix ("~/"))
+      {
+        stripped = stripped.replace ("~", Environment.get_home_dir ());
+      }
+
+      if (!(stripped in past_commands))
+      {
+        foreach (var command in past_commands)
+        {
+          if (command.has_prefix (stripped))
+          {
+            result.add (create_co (command), Match.Score.AVERAGE);
+          }
+        }
+
+        string[] args = split_regex.split (stripped);
+        string? valid_cmd = Environment.find_program_in_path (args[0]);
+
+        if (valid_cmd != null)
+        {
+          // don't allow dangerous commands
+          if (args[0] == "rm") return null;
+          CommandObject? co = create_co (stripped);
+          if (co == null) return null;
+          result.add (co, Match.Score.POOR);
+          co.executed.connect (this.command_executed);
+        }
+      }
+      else
+      {
+        result.add (create_co (stripped), Match.Score.VERY_GOOD);
+      }
+      
+      q.check_cancellable ();
+
+      return result;
+    }
+  }
+}

=== added file 'lib/synapse-plugins/desktop-file-plugin.vala'
--- lib/synapse-plugins/desktop-file-plugin.vala	1970-01-01 00:00:00 +0000
+++ lib/synapse-plugins/desktop-file-plugin.vala	2014-06-16 07:45:32 +0000
@@ -0,0 +1,350 @@
+/*
+ * Copyright (C) 2010 Michal Hruby <[e-mail]>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301  USA.
+ *
+ * Authored by Michal Hruby <[e-mail]>
+ *
+ */
+
+namespace Synapse
+{
+  public class DesktopFilePlugin: Object, Activatable, ItemProvider, ActionProvider
+  {
+    public bool enabled { get; set; default = true; }
+
+    public void activate ()
+    {
+      
+    }
+
+    public void deactivate ()
+    {
+      
+    }
+
+    private class DesktopFileMatch: Object, Match, ApplicationMatch
+    {
+      // for Match interface
+      public string title { get; construct set; }
+      public string description { get; set; default = ""; }
+      public string icon_name { get; construct set; default = ""; }
+      public bool has_thumbnail { get; construct set; default = false; }
+      public string thumbnail_path { get; construct set; }
+      public MatchType match_type { get; construct set; }
+
+      // for ApplicationMatch
+      public AppInfo? app_info { get; set; default = null; }
+      public bool needs_terminal { get; set; default = false; }
+      public string? filename { get; construct set; }
+
+      private string? title_folded = null;
+      public unowned string get_title_folded ()
+      {
+        if (title_folded == null) title_folded = title.casefold ();
+        return title_folded;
+      }
+      
+      public string? title_unaccented { get; set; default = null; }
+      public string? desktop_id { get; set; default = null; }
+
+      public string exec { get; set; }
+
+      public DesktopFileMatch.for_info (DesktopFileInfo info)
+      {
+        Object (filename: info.filename, match_type: MatchType.APPLICATION);
+
+        init_from_info (info);
+      }
+
+      private void init_from_info (DesktopFileInfo info)
+      {
+        this.title = info.name;
+        this.description = info.comment;
+        this.icon_name = info.icon_name;
+        this.exec = info.exec;
+        this.needs_terminal = info.needs_terminal;
+        this.title_folded = info.get_name_folded ();
+        this.title_unaccented = Utils.remove_accents (this.title_folded);
+        this.desktop_id = "application://" + info.desktop_id;
+      }
+    }
+
+    static void register_plugin ()
+    {
+      DataSink.PluginRegistry.get_default ().register_plugin (
+        typeof (DesktopFilePlugin),
+        "Application Search",
+        _ ("Search for and run applications on your computer."),
+        "system-run",
+        register_plugin
+      );
+    }
+    
+    static construct
+    {
+      register_plugin ();
+    }
+    
+    private Gee.List<DesktopFileMatch> desktop_files;
+
+    construct
+    {
+      desktop_files = new Gee.ArrayList<DesktopFileMatch> ();
+      mimetype_map = new Gee.HashMap<string, OpenWithAction> ();
+
+      var dfs = DesktopFileService.get_default ();
+      dfs.reload_started.connect (() => {
+        loading_in_progress = true;
+      });
+      dfs.reload_done.connect (() => {
+        mimetype_map.clear ();
+        desktop_files.clear ();
+        load_all_desktop_files ();
+      });
+
+      load_all_desktop_files ();
+    }
+
+    public signal void load_complete ();
+    private bool loading_in_progress = false;
+
+    private async void load_all_desktop_files ()
+    {
+      loading_in_progress = true;
+      Idle.add_full (Priority.LOW, load_all_desktop_files.callback);
+      yield;
+
+      var dfs = DesktopFileService.get_default ();
+
+      foreach (DesktopFileInfo dfi in dfs.get_desktop_files ())
+      {
+        desktop_files.add (new DesktopFileMatch.for_info (dfi));
+      }
+
+      loading_in_progress = false;
+      load_complete ();
+    }
+    
+    private int compute_relevancy (DesktopFileMatch dfm, int base_relevancy)
+    {
+      var rs = RelevancyService.get_default ();
+      float popularity = rs.get_application_popularity (dfm.desktop_id);
+
+      int r = RelevancyService.compute_relevancy (base_relevancy, popularity);
+      Utils.Logger.debug (this, "relevancy for %s: %d", dfm.desktop_id, r);
+      
+      return r;
+    }
+
+    private void full_search (Query q, ResultSet results,
+                              MatcherFlags flags = 0)
+    {
+      // try to match against global matchers and if those fail, try also exec
+      var matchers = Query.get_matchers_for_query (q.query_string_folded,
+                                                   flags);
+
+      foreach (var dfm in desktop_files)
+      {
+        unowned string folded_title = dfm.get_title_folded ();
+        unowned string unaccented_title = dfm.title_unaccented;
+        bool matched = false;
+        // FIXME: we need to do much smarter relevancy computation in fuzzy re
+        // "sysmon" matching "System Monitor" is very good as opposed to
+        // "seto" matching "System Monitor"
+        foreach (var matcher in matchers)
+        {
+          if (matcher.key.match (folded_title))
+          {
+            results.add (dfm, compute_relevancy (dfm, matcher.value));
+            matched = true;
+            break;
+          }
+          else if (unaccented_title != null && matcher.key.match (unaccented_title))
+          {
+            results.add (dfm, compute_relevancy (dfm, matcher.value - Match.Score.INCREMENT_SMALL));
+            matched = true;
+            break;
+          }
+        }
+        if (!matched && dfm.exec.has_prefix (q.query_string))
+        {
+          results.add (dfm, compute_relevancy (dfm, dfm.exec == q.query_string ?
+            Match.Score.VERY_GOOD : Match.Score.AVERAGE - Match.Score.INCREMENT_SMALL));
+        }
+      }
+    }
+
+    public bool handles_query (Query q)
+    {
+      // we only search for applications
+      if (!(QueryFlags.APPLICATIONS in q.query_type)) return false;
+      if (q.query_string.strip () == "") return false;
+
+      return true;
+    }
+
+    public async ResultSet? search (Query q) throws SearchError
+    {
+      if (loading_in_progress)
+      {
+        // wait
+        ulong signal_id = this.load_complete.connect (() =>
+        {
+          search.callback ();
+        });
+        yield;
+        SignalHandler.disconnect (this, signal_id);
+      }
+      else
+      {
+        // we'll do this so other plugins can send their DBus requests etc.
+        // and they don't have to wait for our blocking (though fast) search
+        // to finish
+        Idle.add_full (Priority.HIGH_IDLE, search.callback);
+        yield;
+      }
+
+      q.check_cancellable ();
+
+      // FIXME: spawn new thread and do the search there?
+      var result = new ResultSet ();
+
+      // FIXME: make sure this is one unichar, not just byte
+      if (q.query_string.length == 1)
+      {
+        var flags = MatcherFlags.NO_SUBSTRING | MatcherFlags.NO_PARTIAL |
+                    MatcherFlags.NO_FUZZY;
+        full_search (q, result, flags);
+      }
+      else
+      {
+        full_search (q, result);
+      }
+
+      q.check_cancellable ();
+
+      return result;
+    }
+    
+    private class OpenWithAction: Object, Match
+    {
+       // for Match interface
+      public string title { get; construct set; }
+      public string description { get; set; default = ""; }
+      public string icon_name { get; construct set; default = ""; }
+      public bool has_thumbnail { get; construct set; default = false; }
+      public string thumbnail_path { get; construct set; }
+      public MatchType match_type { get; construct set; }
+      
+      public DesktopFileInfo desktop_info { get; private set; }
+      
+      public OpenWithAction (DesktopFileInfo info)
+      {
+        Object ();
+        
+        init_with_info (info);
+      }
+
+      private void init_with_info (DesktopFileInfo info)
+      {
+        this.title = _ ("Open with %s").printf (info.name);
+        this.icon_name = info.icon_name;
+        this.description = _ ("Opens current selection using %s").printf (info.name);
+        this.desktop_info = info;
+      }
+      
+      protected void execute (Match? match)
+      {
+        UriMatch uri_match = match as UriMatch;
+        return_if_fail (uri_match != null);
+        
+        var f = File.new_for_uri (uri_match.uri);
+        try
+        {
+          var app_info = new DesktopAppInfo.from_filename (desktop_info.filename);
+          List<File> files = new List<File> ();
+          files.prepend (f);
+          app_info.launch (files, new Gdk.AppLaunchContext ());
+        }
+        catch (Error err)
+        {
+          warning ("%s", err.message);
+        }
+      }
+    }
+    
+    private Gee.Map<string, Gee.List<OpenWithAction> > mimetype_map;
+
+    public ResultSet? find_for_match (ref Query query, Match match)
+    {
+      if (match.match_type != MatchType.GENERIC_URI) return null;
+
+      var uri_match = match as UriMatch;
+      return_val_if_fail (uri_match != null, null);
+      
+      if (uri_match.mime_type == null) return null;
+
+      Gee.List<OpenWithAction> ow_list = mimetype_map[uri_match.mime_type];
+      /* Query DesktopFileService only if is necessary */
+      if (ow_list == null)
+      {
+        /* Initialize ow_list */
+        ow_list = new Gee.LinkedList<OpenWithAction> ();
+        mimetype_map[uri_match.mime_type] = ow_list;
+        var dfs = DesktopFileService.get_default ();
+        var list_for_mimetype = dfs.get_desktop_files_for_type (uri_match.mime_type);
+        /* If there's more than one application, fill the ow list */
+        if (list_for_mimetype.size > 1)
+        {
+          foreach (var entry in list_for_mimetype)
+          {
+            ow_list.add (new OpenWithAction (entry));
+          }
+        }
+        else return null;
+      }
+      else if (ow_list.size == 0) return null;
+
+      var rs = new ResultSet ();
+      
+      if (query.query_string == "")
+      {
+        foreach (var action in ow_list)
+        {
+          rs.add (action, Match.Score.POOR);
+        }
+      }
+      else
+      {
+        var matchers = Query.get_matchers_for_query (query.query_string, 0,
+          RegexCompileFlags.OPTIMIZE | RegexCompileFlags.CASELESS);
+        foreach (var action in ow_list)
+        {
+          foreach (var matcher in matchers)
+          {
+            if (matcher.key.match (action.title))
+            {
+              rs.add (action, matcher.value);
+              break;
+            }
+          }
+        }
+      }
+
+      return rs;
+    }
+  }
+}

=== modified file 'src/Backend/App.vala'
--- src/Backend/App.vala	2014-04-24 10:43:44 +0000
+++ src/Backend/App.vala	2014-06-16 07:45:32 +0000
@@ -16,8 +16,20 @@
 //  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 //
 
+errordomain IconError {
+    NOT_FOUND
+}
+
 public class Slingshot.Backend.App : Object {
 
+    public enum AppType {
+        APP,
+        COMMAND,
+        SYNAPSE
+    }
+
+    public signal void start_search (Synapse.SearchMatch search_match, Synapse.Match? target);
+
     public string name { get; construct set; }
     public string description { get; private set; default = ""; }
     public string desktop_id { get; construct set; }
@@ -30,13 +42,17 @@
     public string desktop_path { get; private set; }
     public string categories { get; private set; }
     public string generic_name { get; private set; default = ""; }
+    public AppType app_type { get; private set; default = AppType.APP; }
 
-    private bool is_command = false;
+    public Synapse.Match? match { get; private set; default = null; }
+    public Synapse.Match? target { get; private set; default = null; }
 
     public signal void icon_changed ();
     public signal void launched (App app);
 
     public App (GMenu.TreeEntry entry) {
+        app_type = AppType.APP;
+
         unowned GLib.DesktopAppInfo info = entry.get_app_info ();
         name = info.get_display_name ().dup ();
         description = info.get_description ().dup () ?? name;
@@ -70,6 +86,7 @@
     }
 
     public App.from_command (string command) {
+        app_type = AppType.COMMAND;
 
         name = command;
         description = _("Run this command...");
@@ -77,7 +94,20 @@
         desktop_id = command;
         icon_name = "system-run";
 
-        is_command = true;
+        update_icon ();
+
+    }
+
+    public App.from_synapse_match (Synapse.Match match, Synapse.Match? target = null) {
+
+        app_type = AppType.SYNAPSE;
+
+        name = match.title;
+        description = match.description;
+        icon_name = match.icon_name;
+
+        this.match = match;
+        this.target = target;
 
         update_icon ();
 
@@ -98,7 +128,31 @@
         }
     }
 
-    public Gdk.Pixbuf load_icon (int size) {
+    public Gdk.Pixbuf? load_icon (int size) {
+        if (app_type == AppType.SYNAPSE) {
+            try {
+                // for contacts we can load the thumbnail because we expect it to be
+                // the avatar. For other types it'd be ridiculously small.
+                if (match.match_type == Synapse.MatchType.CONTACT && match.has_thumbnail) {
+                    return new Gdk.Pixbuf.from_file_at_scale (match.thumbnail_path, size, size, true);
+                }
+
+                var icon = Icon.new_for_string (icon_name);
+                var info = Gtk.IconTheme.get_default ().lookup_by_gicon (icon,
+                    size, Gtk.IconLookupFlags.FORCE_SIZE);
+
+                if (info == null)
+                    throw new IconError.NOT_FOUND ("Not found");
+
+                return info.load_icon ();
+            } catch (Error e) {
+                warning ("Failed to load icon: %s\n", e.message);
+            }
+
+            return Slingshot.icon_theme.load_icon ("application-default-icon",
+                size, Gtk.IconLookupFlags.FORCE_SIZE);
+        }
+
         Gdk.Pixbuf icon = null;
         var flags = Gtk.IconLookupFlags.FORCE_SIZE;
 
@@ -156,19 +210,35 @@
         return icon;
     }
 
-    public void launch () {
+    public bool launch () {
         try {
-            if (is_command) {
-                debug (@"Launching command: $name");
-                Process.spawn_command_line_async (exec);
-            } else {
-                launched (this); // Emit launched signal
-                new DesktopAppInfo (desktop_id).launch (null, null);
-                debug (@"Launching application: $name");
+            switch (app_type) {
+                case AppType.COMMAND:
+                    debug (@"Launching command: $name");
+                    Process.spawn_command_line_async (exec);
+                    break;
+                case AppType.APP:
+                    launched (this); // Emit launched signal
+                    new DesktopAppInfo (desktop_id).launch (null, null);
+                    debug (@"Launching application: $name");
+                    break;
+                case AppType.SYNAPSE:
+                    if (match.match_type == Synapse.MatchType.SEARCH) {
+                        start_search (match as Synapse.SearchMatch, target);
+                        return false;
+                    } else {
+                        if (target == null)
+                            Backend.SynapseSearch.find_actions_for_match (match).get (0).execute_with_target (match);
+                        else
+                            match.execute_with_target (target);
+                    }
+                    break;
             }
         } catch (Error e) {
             warning ("Failed to launch %s: %s", name, exec);
         }
+
+        return true;
     }
 
 }

=== modified file 'src/Backend/AppSystem.vala'
--- src/Backend/AppSystem.vala	2014-04-24 21:11:21 +0000
+++ src/Backend/AppSystem.vala	2014-06-16 07:45:32 +0000
@@ -161,7 +161,9 @@
         foreach (Gee.ArrayList<App> category in apps.values) {
             foreach (App app in category) {
 
-                if (GCC_PANEL_CATEGORY in app.categories || SWITCHBOARD_PLUG_CATEGORY in app.categories)
+                if (app.categories != null
+                    && (GCC_PANEL_CATEGORY in app.categories
+                    || SWITCHBOARD_PLUG_CATEGORY in app.categories))
                     continue;
                 
 
@@ -196,19 +198,19 @@
             foreach (App app in category) {
                 if (!(app.exec in sorted_apps_execs)) {
                     sorted_apps_execs += app.exec;
-                    if (search in app.name.down ()) {
+                    if (app.name != null && search in app.name.down ()) {
                         if (search == app.name.down ()[0:search.length])
                             app.relevancy = 0.5 - app.popularity; // It must be minor than 1.0
                         else
                             app.relevancy = app.name.length / search.length - app.popularity;
                         filtered.add (app);
-                    } else if (search in app.exec.down ()) {
+                    } else if (app.exec != null && search in app.exec.down ()) {
                         app.relevancy = app.exec.length / search.length * 10.0 - app.popularity;
                         filtered.add (app);
-                    } else if (search in app.description.down ()) {
+                    } else if (app.description != null && search in app.description.down ()) {
                         app.relevancy = app.description.length / search.length - app.popularity;
                         filtered.add (app);
-                    } else if (search in app.generic_name.down ()) {
+                    } else if (app.generic_name != null && search in app.generic_name.down ()) {
                         app.relevancy = app.generic_name.length / search.length - app.popularity;
                         filtered.add (app);
                     }  else if (app.keywords != null) {
@@ -236,4 +238,4 @@
 
     }
 
-}
\ No newline at end of file
+}

=== added file 'src/Backend/SynapseSearch.vala'
--- src/Backend/SynapseSearch.vala	1970-01-01 00:00:00 +0000
+++ src/Backend/SynapseSearch.vala	2014-06-16 07:45:32 +0000
@@ -0,0 +1,163 @@
+// -*- Mode: vala; indent-tabs-mode: nil; tab-width: 4 -*-
+//
+//  Copyright (C) 2011-2012 Giulio Collura
+//
+//  This program is free software: you can redistribute it and/or modify
+//  it under the terms of the GNU 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 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/>.
+//
+
+namespace Slingshot.Backend {
+
+    public class SynapseSearch : Object {
+
+        private static Type[] plugins = {
+            typeof (Synapse.CommandPlugin),
+            typeof (Synapse.DesktopFilePlugin)
+        };
+
+        private static Synapse.DataSink? sink = null;
+        private static Gee.HashMap<string,Gdk.Pixbuf> favicon_cache;
+
+        Cancellable? current_search = null;
+
+        public SynapseSearch () {
+
+            if (sink == null) {
+                sink = new Synapse.DataSink ();
+                foreach (var plugin in plugins) {
+                    sink.register_static_plugin (plugin);
+                }
+
+                favicon_cache = new Gee.HashMap<string,Gdk.Pixbuf> ();
+            }
+        }
+
+        public async Gee.List<Synapse.Match>? search (string text, Synapse.SearchProvider? provider = null) {
+
+            if (current_search != null)
+                current_search.cancel ();
+
+            if (provider == null)
+                provider = sink;
+
+            var results = new Synapse.ResultSet ();
+
+            try {
+                return yield provider.search (text, Synapse.QueryFlags.ALL, results, current_search);
+            } catch (Error e) { warning (e.message); }
+
+            return null;
+        }
+
+        public static Gee.List<Synapse.Match> find_actions_for_match (Synapse.Match match) {
+            return sink.find_actions_for_match (match, null, Synapse.QueryFlags.ALL);
+        }
+
+        /**
+         * Attempts to load a favicon for an UriMatch and caches the icon
+         *
+         * @param match       The UriMatch
+         * @param size        The icon size at which to load the icon. If the favicon is smaller than
+         *                    that size, null will be returned
+         * @param cancellable Cancellable for the loading operations
+         * @return            The pixbuf or null if loading failed or the icon was too small
+         */
+        public static async Gdk.Pixbuf? get_favicon_for_match (Synapse.UriMatch match, int size,
+            Cancellable? cancellable = null) {
+
+            var soup_uri = new Soup.URI (match.uri);
+            if (!soup_uri.scheme.has_prefix ("http"))
+                return null;
+
+            Gdk.Pixbuf? pixbuf = null;
+
+            if (favicon_cache.has_key (soup_uri.host))
+                return favicon_cache.get (soup_uri.host);
+
+            var url = "%s://%s/favicon.ico".printf (soup_uri.scheme, soup_uri.host);
+
+            var msg = new Soup.Message ("GET", url);
+            var session = new Soup.Session ();
+            session.use_thread_context = true;
+
+            try {
+                var stream = yield session.send_async (msg, cancellable);
+                if (stream != null) {
+                    pixbuf = yield new Gdk.Pixbuf.from_stream_async (stream, cancellable);
+                    // as per design decision, icons that are smaller than requested will not
+                    // be displayed, instead the fallback should be used, so we return null
+                    if (pixbuf.width < size)
+                        pixbuf = null;
+                }
+            } catch (Error e) {}
+
+            if (cancellable.is_cancelled ())
+                return null;
+
+            // we set the cache in any case, even if things failed. No need to
+            // try requesting an icon again and again
+            favicon_cache.set (soup_uri.host, pixbuf);
+
+            return pixbuf;
+        }
+
+        // copied from synapse-ui with some slight changes
+        public static string markup_string_with_search (string text, string pattern) {
+
+            string markup = "%s";
+
+            if (pattern == "") {
+                return markup.printf (Markup.escape_text (text));
+            }
+
+            // if no text found, use pattern
+            if (text == "") {
+                return markup.printf (Markup.escape_text (pattern));
+            }
+
+            var matchers = Synapse.Query.get_matchers_for_query (pattern, 0,
+                RegexCompileFlags.OPTIMIZE | RegexCompileFlags.CASELESS);
+
+            string? highlighted = null;
+            foreach (var matcher in matchers) {
+                MatchInfo mi;
+                if (matcher.key.match (text, 0, out mi)) {
+                    int start_pos;
+                    int end_pos;
+                    int last_pos = 0;
+                    int cnt = mi.get_match_count ();
+                    StringBuilder res = new StringBuilder ();
+                    for (int i = 1; i < cnt; i++) {
+                        mi.fetch_pos (i, out start_pos, out end_pos);
+                        warn_if_fail (start_pos >= 0 && end_pos >= 0);
+                        res.append (Markup.escape_text (text.substring (last_pos, start_pos - last_pos)));
+                        last_pos = end_pos;
+                        res.append (Markup.printf_escaped ("<b>%s</b>", mi.fetch (i)));
+                        if (i == cnt - 1) {
+                            res.append (Markup.escape_text (text.substring (last_pos)));
+                        }
+                    }
+                    highlighted = res.str;
+                    break;
+                }
+            }
+
+            if (highlighted != null) {
+                return markup.printf (highlighted);
+            } else {
+                return markup.printf (Markup.escape_text(text));
+            }
+        }
+    }
+}
+

=== modified file 'src/Slingshot.vala'
--- src/Slingshot.vala	2013-12-26 00:08:04 +0000
+++ src/Slingshot.vala	2014-06-16 07:45:32 +0000
@@ -36,20 +36,20 @@
         build_version_info = Build.VERSION_INFO;
 
         program_name = "Slingshot";
-	    exec_name = "slingshot-launcher";
-	    app_copyright = "GPLv3";
-	    app_icon = "";
-	    app_launcher = "";
+        exec_name = "slingshot-launcher";
+        app_copyright = "GPLv3";
+        app_icon = "";
+        app_launcher = "";
         app_years = "2011-2012";
         application_id = "net.launchpad.slingshot";
-	    main_url = "https://launchpad.net/slingshot";
-	    bug_url = "https://bugs.launchpad.net/slingshot";
-	    help_url = "https://answers.launchpad.net/slingshot";
-	    translate_url = "https://translations.launchpad.net/slingshot";
+        main_url = "https://launchpad.net/slingshot";
+        bug_url = "https://bugs.launchpad.net/slingshot";
+        help_url = "https://answers.launchpad.net/slingshot";
+        translate_url = "https://translations.launchpad.net/slingshot";
 
-	    about_authors = {"Giulio Collura <[e-mail]>",
-	                     "Andrea Basso <[e-mail]"};
-	    about_artists = {"Harvey Cabaguio 'BassUltra' <[e-mail]>",
+        about_authors = {"Giulio Collura <[e-mail]>",
+                         "Andrea Basso <[e-mail]"};
+        about_artists = {"Harvey Cabaguio 'BassUltra' <[e-mail]>",
                          "Daniel Foré <[e-mail]>"};
         about_translators = "Launchpad Translators";
         about_license_type = Gtk.License.GPL_3_0;

=== modified file 'src/SlingshotView.vala'
--- src/SlingshotView.vala	2014-05-28 08:48:51 +0000
+++ src/SlingshotView.vala	2014-06-16 07:45:32 +0000
@@ -27,7 +27,8 @@
     public class SlingshotView : Granite.Widgets.PopOver {
 
         // Widgets
-        public Gtk.SearchEntry search_entry;
+        public Gtk.SearchEntry dummy_search_entry;
+        public Widgets.LargeSearchEntry real_search_entry;
         public Gtk.Stack stack;
         public Granite.Widgets.ModeButton view_selector;
 
@@ -39,6 +40,7 @@
         public Gtk.Grid top;
         public Gtk.Grid center;
         public Gtk.Grid container;
+        public Gtk.Stack main_stack;
         public Gtk.Box content_area;
         private Gtk.EventBox event_box;
 
@@ -46,11 +48,11 @@
         private Gee.ArrayList<GMenu.TreeDirectory> categories;
         public Gee.HashMap<string, Gee.ArrayList<Backend.App>> apps;
 
-        private int current_position = 0;
-        private int search_view_position = 0;
         private Modality modality;
         private bool can_trigger_hotcorner = true;
 
+        private Backend.SynapseSearch synapse;
+
         // Sizes
         public int columns {
             get {
@@ -91,6 +93,7 @@
             Slingshot.icon_theme = Gtk.IconTheme.get_default ();
 
             app_system = new Backend.AppSystem ();
+            synapse = new Backend.SynapseSearch ();
 
             categories = app_system.get_categories ();
             apps = app_system.get_apps ();
@@ -133,6 +136,10 @@
             // Create the base container
             container = new Gtk.Grid ();
 
+            main_stack = new Gtk.Stack ();
+
+            main_stack.add_named (container, "apps");
+
             // Add top bar
             top = new Gtk.Grid ();
 
@@ -154,16 +161,16 @@
             else
                 view_selector.selected = 0;
 
-            search_entry = new Gtk.SearchEntry ();
-            search_entry.placeholder_text = _("Search Apps…");
-            search_entry.width_request = 250;
-            search_entry.button_press_event.connect ((e) => {return e.button == 3;});
+            dummy_search_entry = new Gtk.SearchEntry ();
+            dummy_search_entry.placeholder_text = _("Search Apps…");
+            dummy_search_entry.width_request = 250;
+            dummy_search_entry.button_press_event.connect ((e) => {return e.button == 3;});
 
             if (Slingshot.settings.show_category_filter) {
                 top.attach (view_selector, 0, 0, 1, 1);
             }
             top.attach (top_separator, 1, 0, 1, 1);
-            top.attach (search_entry, 2, 0, 1, 1);
+            top.attach (dummy_search_entry, 2, 0, 1, 1);
 
             center = new Gtk.Grid ();
             
@@ -178,12 +185,21 @@
             stack.add_named (scrolled_normal, "normal");
 
             // Create the "SEARCH_VIEW"
+            var search_view_container = new Gtk.Box (Gtk.Orientation.VERTICAL, 0);
+
+            real_search_entry = new Widgets.LargeSearchEntry ();
+            real_search_entry.margin_left = real_search_entry.margin_right = 12;
+
             search_view = new Widgets.SearchView (this);
-
-            foreach (Gee.ArrayList<Backend.App> app_list in apps.values) {
-                search_view.add_apps (app_list);
-            }
-            stack.add_named (search_view, "search");
+            search_view.start_search.connect ((match, target) => {
+                search.begin (real_search_entry.text, match, target);
+            });
+
+            search_view_container.pack_start (real_search_entry, false);
+            search_view_container.pack_start (new Gtk.Separator (Gtk.Orientation.HORIZONTAL), false);
+            search_view_container.pack_start (search_view);
+
+            main_stack.add_named (search_view_container, "search");
 
             // Create the "CATEGORY_VIEW"
             category_view = new Widgets.CategoryView (this);
@@ -193,7 +209,7 @@
             container.attach (Utils.set_padding (center, 0, 12, 12, 12), 0, 1, 1, 1);
 
             event_box = new Gtk.EventBox ();
-            event_box.add (container);
+            event_box.add (main_stack);
             // Add the container to the dialog's content area
             content_area = get_content_area () as Gtk.Box;
             content_area.pack_start (event_box);
@@ -265,24 +281,37 @@
         private void connect_signals () {
 
             this.focus_in_event.connect (() => {
-                search_entry.grab_focus ();
+                get_current_search_entry ().grab_focus ();
                 return false;
             });
 
             event_box.key_press_event.connect (on_key_press);
-            search_entry.key_press_event.connect (search_entry_key_press);
-
-            search_entry.search_changed.connect (() => this.search.begin (search_entry.text));
-            search_entry.grab_focus ();
-
-            search_entry.activate.connect (() => {
-                if (modality == Modality.SEARCH_VIEW) {
-                    search_view.launch_selected ();
-                    hide ();
-                } else {
-                    if (get_focus () as Widgets.AppEntry != null) // checking the selected widget is an AppEntry
-                        ((Widgets.AppEntry) get_focus ()).launch_app ();
-                }
+            dummy_search_entry.key_press_event.connect (search_entry_key_press);
+            real_search_entry.widget.key_press_event.connect (search_entry_key_press);
+
+            real_search_entry.search_changed.connect (() => {
+                search.begin (real_search_entry.text);
+            });
+            dummy_search_entry.search_changed.connect (() => {
+                if (modality != Modality.SEARCH_VIEW)
+                    set_modality (Modality.SEARCH_VIEW);
+            });
+            dummy_search_entry.grab_focus ();
+
+            dummy_search_entry.activate.connect (search_entry_activated);
+            real_search_entry.widget.activate.connect (search_entry_activated);
+
+            // the focus-out event is fired as soon as the stack transition is ended
+            // at which point we're able to focus the real_search_entry
+            dummy_search_entry.focus_out_event.connect (() => {
+                real_search_entry.text = dummy_search_entry.text;
+                real_search_entry.widget.grab_focus ();
+                var cursor_pos = real_search_entry.text.length;
+                real_search_entry.widget.select_region (cursor_pos, cursor_pos);
+
+                dummy_search_entry.text = "";
+
+                return false;
             });
 
             search_view.app_launched.connect (() => hide ());
@@ -365,9 +394,33 @@