~canonical-dx-team/unity/unity.fix-ql-losing-focus

// -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
/*
 * Copyright (C) 2011 Canonical Ltd
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 3 as
 * published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 * Authored by: Mikkel Kamstrup Erlandsen <mikkel.kamstrup@canonical.com>
 */

#include "LauncherEntryRemoteModel.h"

static void nux_object_destroy_notify (nux::Object *obj);

/**
 * Helper class implementing the remote API to control the icons in the
 * launcher. Also known as the com.canonical.Unity.LauncherEntry DBus API.
 * It enables clients to dynamically control their launcher icons by
 * adding a counter, progress indicator, or emblem to it. It also supports
 * adding a quicklist menu by means of the dbusmenu library.
 *
 * We take care to print out any client side errors or oddities in detail,
 * in order to help third party developers as much as possible when integrating
 * with Unity.
 */
LauncherEntryRemoteModel::LauncherEntryRemoteModel()
{
  GError          *error;

  _launcher_entry_dbus_signal_id = 0;

  error = NULL;
  _conn = g_bus_get_sync (G_BUS_TYPE_SESSION, NULL, &error);
  if (error)
    {
      g_warning ("Unable to connect to session bus: %s", error->message);
      g_error_free (error);
      return;
    }
  
  _entries_by_uri = g_hash_table_new_full (g_str_hash, g_str_equal, g_free,
                                           (GDestroyNotify) nux_object_destroy_notify);

  /* Listen for *all* signals on the "com.canonical.Unity.LauncherEntry"
   * interface, no matter who the sender is */
  _launcher_entry_dbus_signal_id =
      g_dbus_connection_signal_subscribe (_conn,
                                          NULL,                       // sender
                                          "com.canonical.Unity.LauncherEntry",
                                          NULL,                       // member
                                          NULL,                       // path
                                          NULL,                       // arg0
                                          G_DBUS_SIGNAL_FLAGS_NONE,
                                          &on_launcher_entry_signal_received,
                                          this,
                                          NULL);

  _dbus_name_owner_changed_signal_id =
      g_dbus_connection_signal_subscribe (_conn,
                                          "org.freedesktop.DBus",     // sender
                                          "org.freedesktop.DBus",     // interface
                                          "NameOwnerChanged",         // member
                                          "/org/freedesktop/DBus",    // path
                                          NULL,                       // arg0
                                          G_DBUS_SIGNAL_FLAGS_NONE,
                                          &on_dbus_name_owner_changed_signal_received,
                                          this,
                                          NULL);
}

LauncherEntryRemoteModel::~LauncherEntryRemoteModel()
{
  g_hash_table_destroy (_entries_by_uri);
  _entries_by_uri = NULL;

  if (_launcher_entry_dbus_signal_id && _conn)
    {
      g_dbus_connection_signal_unsubscribe (_conn,
                                            _launcher_entry_dbus_signal_id);
      _launcher_entry_dbus_signal_id = 0;
    }
  
  if (_conn)
    {
      g_object_unref (_conn);
      _conn = NULL;
    }
}

/**
 * Get a pointer to the default LauncherEntryRemoteModel singleton for this
 * process. The return value should not be freed.
 */
LauncherEntryRemoteModel*
LauncherEntryRemoteModel::GetDefault()
{
  static LauncherEntryRemoteModel *singleton = NULL;

  if (singleton == NULL)
    singleton = new LauncherEntryRemoteModel ();

  return singleton;
}

/**
 * Return the number of unique LauncherEntryRemote objects managed by the model.
 * The entries are identified by their LauncherEntryRemote::AppUri property.
 */
guint
LauncherEntryRemoteModel::Size ()
{
  return g_hash_table_size (_entries_by_uri);
}

/**
 * Return a pointer to a LauncherEntryRemote if there is one for app_uri,
 * otherwise NULL. The returned object should not be freed.
 *
 * App Uris look like application://$desktop_file_id, where desktop_file_id
 * is the base name of the .desktop file for the application including the
 * .desktop extension. Eg. application://firefox.desktop.
 */
LauncherEntryRemote*
LauncherEntryRemoteModel::LookupByUri (const gchar *app_uri)
{
  gpointer entry;

  g_return_val_if_fail (app_uri != NULL, NULL);

  entry = g_hash_table_lookup (_entries_by_uri,  app_uri);
  return static_cast<LauncherEntryRemote *> (entry);
}

/**
 * Return a pointer to a LauncherEntryRemote if there is one for desktop_id,
 * otherwise NULL. The returned object should not be freed.
 *
 * The desktop id is the base name of the .desktop file for the application
 * including the .desktop extension. Eg. firefox.desktop.
 */
LauncherEntryRemote*
LauncherEntryRemoteModel::LookupByDesktopId (const gchar *desktop_id)
{
  LauncherEntryRemote *entry;
  gchar               *app_uri;

  g_return_val_if_fail (desktop_id != NULL, NULL);

  app_uri = g_strconcat ("application://", desktop_id, NULL);
  entry = LookupByUri (app_uri);
  g_free (app_uri);

  return entry;
}

/**
 * Return a pointer to a LauncherEntryRemote if there is one for
 * desktop_file_path, otherwise NULL. The returned object should not be freed.
 */
LauncherEntryRemote*
LauncherEntryRemoteModel::LookupByDesktopFile (const gchar *desktop_file_path)
{
  LauncherEntryRemote *entry;
  gchar               *desktop_id, *app_uri;

  g_return_val_if_fail (desktop_file_path != NULL, NULL);

  desktop_id = g_path_get_basename (desktop_file_path);
  app_uri = g_strconcat ("application://", desktop_id, NULL);
  entry = LookupByUri (app_uri);
  g_free (app_uri);
  g_free (desktop_id);

  return entry;
}

/**
 * Get a list of all application URIs which have registered with the launcher
 * API. The returned GList should be freed with g_list_free(), but the URIs
 * should not be changed or freed.
 */
GList*
LauncherEntryRemoteModel::GetUris ()
{
  return (GList*) g_hash_table_get_keys (_entries_by_uri);
}

/**
 * Add or update a remote launcher entry.
 *
 * If 'entry' has a floating reference it will be consumed.
 */
void
LauncherEntryRemoteModel::AddEntry (LauncherEntryRemote *entry)
{
  LauncherEntryRemote *existing_entry;

  g_return_if_fail (entry != NULL);

  entry->SinkReference ();

  existing_entry = LookupByUri (entry->AppUri ());
  if (existing_entry != NULL)
    {
      existing_entry->Update (entry);
      entry->UnReference ();
    }
  else
    {
      /* The ref on entry will be removed by the hash table itself */
      g_hash_table_insert (_entries_by_uri, g_strdup (entry->AppUri ()), entry);
      entry_added.emit (entry);
    }
}

/**
 * Add or update a remote launcher entry.
 *
 * If 'entry' has a floating reference it will be consumed.
 */
void
LauncherEntryRemoteModel::RemoveEntry (LauncherEntryRemote *entry)
{
  g_return_if_fail (entry != NULL);

  entry->Reference ();

  if (g_hash_table_remove (_entries_by_uri, entry->AppUri ()))
    entry_removed.emit (entry);
  
  entry->UnReference ();
}

/**
 * Handle an incoming Update() signal from DBus
 */
void
LauncherEntryRemoteModel::HandleUpdateRequest (const gchar *sender_name,
                                               GVariant    *parameters)
{
  LauncherEntryRemote      *entry;
  gchar                    *app_uri;
  GVariantIter             *prop_iter;

  g_return_if_fail (sender_name != NULL);
  g_return_if_fail (parameters != NULL);

  if (!g_variant_is_of_type (parameters, G_VARIANT_TYPE ("(sa{sv})")))
    {
      g_warning ("Received 'com.canonical.Unity.LauncherEntry.Update' with"
                 " illegal payload signature '%s'. Expected '(sa{sv})'.",
                 g_variant_get_type_string (parameters));
      return;
    }

  if (sender_name == NULL)
    {
      g_critical ("Received 'com.canonical.Unity.LauncherEntry.Update' from"
                  " an undefined sender. This may happen if you are trying "
                  "to run Unity on a p2p DBus connection.");
      return;
    }

  g_variant_get (parameters, "(sa{sv})", &app_uri, &prop_iter);
  entry = LookupByUri (app_uri);

  if (entry)
    {
      /* It's important that we update the DBus name first since it might
       * unset the quicklist if it changes */
      entry->SetDBusName (sender_name);
      entry->Update (prop_iter);
    }
  else
    {
      entry = new LauncherEntryRemote (sender_name, parameters);
      AddEntry (entry); // consumes floating ref on entry
    }

  g_variant_iter_free (prop_iter);
  g_free (app_uri);
}

void
LauncherEntryRemoteModel::on_launcher_entry_signal_received (GDBusConnection *connection,
                                   const gchar     *sender_name,
                                   const gchar     *object_path,
                                   const gchar     *interface_name,
                                   const gchar     *signal_name,
                                   GVariant        *parameters,
                                   gpointer         user_data)
{
  LauncherEntryRemoteModel *self;

  self = static_cast<LauncherEntryRemoteModel *> (user_data);

  if (parameters == NULL)
    {
      g_warning ("Received DBus signal '%s.%s' with empty payload from %s",
                 interface_name, signal_name, sender_name);
      return;
    }

  if (g_strcmp0 (signal_name, "Update") == 0)
    {
      self->HandleUpdateRequest (sender_name, parameters);
    }
  else
    {
      g_warning ("Unknown signal '%s.%s' from %s",
                 interface_name, signal_name, sender_name);
    }
}

void 
LauncherEntryRemoteModel::on_dbus_name_owner_changed_signal_received (GDBusConnection *connection,
                                            const gchar *sender_name,
                                            const gchar *object_path,
                                            const gchar *interface_name,
                                            const gchar *signal_name,
                                            GVariant *parameters,
                                            gpointer user_data)
{
  LauncherEntryRemoteModel *self;
  char *name, *before, *after;
  
  self = static_cast<LauncherEntryRemoteModel *> (user_data);
  
  if (parameters == NULL)
    return;
  
  g_variant_get (parameters, "(sss)", &name, &before, &after);
  
  if (!after[0])
  {
    // Name gone, find and destroy LauncherEntryRemote
    GHashTableIter iter;
    GList *remove = NULL, *l;
    gpointer key, value;

    g_hash_table_iter_init (&iter, self->_entries_by_uri);
    while (g_hash_table_iter_next (&iter, &key, &value)) 
    {
      /* do something with key and value */
      LauncherEntryRemote *entry = static_cast<LauncherEntryRemote *> (value);
      if (g_str_equal (entry->DBusName (), name))
        remove = g_list_prepend (remove, entry);
    }
    
    for (l = remove; l; l = l->next)
      self->RemoveEntry (static_cast<LauncherEntryRemote *> (l->data));
    
    g_list_free (remove);
  }
}

static void
nux_object_destroy_notify (nux::Object *obj)
{
  if (G_LIKELY (obj != NULL))
    obj->UnReference();
}