/* util header */

/* vim: set sw=2 et: */

/*

 * Copyright (C) 2001 Havoc Pennington

 * Copyright (C) 2006-2007 Vincent Untz

 *

 * This library is free software; you can redistribute it and/or

 * modify it under the terms of the GNU Library 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

 * Library General Public License for more details.

 *

 * You should have received a copy of the GNU Library General Public

 * License along with this library; if not, see <http://www.gnu.org/licenses/>.

 */

#include <config.h>

#include <glib/gi18n-lib.h>

#include "util.h"

#include "xutils.h"

#include "private.h"

#include <gdk/gdkx.h>

#include <string.h>

#ifdef HAVE_XRES

#include <X11/extensions/XRes.h>

#endif

/**

 * SECTION:resource

 * @short_description: reading resource usage of X clients.

 * @see_also: wnck_window_get_xid(), wnck_application_get_xid(), wnck_window_get_pid(), wnck_application_get_pid()

 * @stability: Unstable

 *

 * libwnck provides an easy-to-use interface to the XRes X server extension to

 * read resource usage of X clients, which can be defined either by the X

 * window ID of one of their windows or by the process ID of their process.

 */

/**

 * SECTION:misc

 * @short_description: other additional features.

 * @stability: Unstable

 *

 * These functions are utility functions providing some additional features to

 * libwnck users.

 */

/**

 * SECTION:icons

 * @short_description: icons related functions.

 * @stability: Unstable

 *

 * These functions are utility functions to manage icons for #WnckWindow and

 * #WnckApplication.

 */

typedef enum

{

  WNCK_EXT_UNKNOWN = 0,

  WNCK_EXT_FOUND = 1,

  WNCK_EXT_MISSING = 2

} WnckExtStatus;

#if 0

/* useful for debugging */

static void

_wnck_print_resource_usage (WnckResourceUsage *usage)

{

  if (!usage)

    return;

  g_print ("\twindows       : %d\n"

           "\tGCs           : %d\n"

           "\tfonts         : %d\n"

           "\tpixmaps       : %d\n"

           "\tpictures      : %d\n"

           "\tglyphsets     : %d\n"

           "\tcolormaps     : %d\n"

           "\tpassive grabs : %d\n"

           "\tcursors       : %d\n"

           "\tunknowns      : %d\n"

           "\tpixmap bytes  : %ld\n"

           "\ttotal bytes   : ~%ld\n",

           usage->n_windows,

           usage->n_gcs,

           usage->n_fonts,

           usage->n_pixmaps,

           usage->n_pictures,

           usage->n_glyphsets,

           usage->n_colormap_entries,

           usage->n_passive_grabs,

           usage->n_cursors,

           usage->n_other,

           usage->pixmap_bytes,

           usage->total_bytes_estimate);

}

#endif

static WnckExtStatus

wnck_init_resource_usage (GdkDisplay *gdisplay)

{

  WnckExtStatus status;

  status = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (gdisplay),

                                               "wnck-xres-status"));

  if (status == WNCK_EXT_UNKNOWN)

    {

#ifdef HAVE_XRES

      Display *xdisplay = GDK_DISPLAY_XDISPLAY (gdisplay);

      int event, error;

      if (!XResQueryExtension (xdisplay, &event, &error))

        status = WNCK_EXT_MISSING;

      else

        status = WNCK_EXT_FOUND;

#else

      status = WNCK_EXT_MISSING;

#endif

      g_object_set_data (G_OBJECT (gdisplay),

                         "wnck-xres-status",

                         GINT_TO_POINTER (status));

    }

  g_assert (status != WNCK_EXT_UNKNOWN);

  return status;

}

/**

 * wnck_xid_read_resource_usage:

 * @gdk_display: a <classname>GdkDisplay</classname>.

 * @xid: an X window ID.

 * @usage: return location for the X resource usage of the application owning

 * the X window ID @xid.

 *

 * Looks for the X resource usage of the application owning the X window ID

 * @xid on display @gdisplay. If no resource usage can be found, then all

 * fields of @usage are set to 0.

 *

 * To properly work, this function requires the XRes extension on the X server.

 *

 * Since: 2.6

 */

void

wnck_xid_read_resource_usage (GdkDisplay        *gdisplay,

                              gulong             xid,

                              WnckResourceUsage *usage)

{

  g_return_if_fail (usage != NULL);

  memset (usage, '\0', sizeof (*usage));

  if (wnck_init_resource_usage (gdisplay) == WNCK_EXT_MISSING)

    return;

#ifdef HAVE_XRES

 {

   Display *xdisplay;

   XResType *types;

   int n_types;

   unsigned long pixmap_bytes;

   int i;

   Atom pixmap_atom;

   Atom window_atom;

   Atom gc_atom;

   Atom picture_atom;

   Atom glyphset_atom;

   Atom font_atom;

   Atom colormap_entry_atom;

   Atom passive_grab_atom;

   Atom cursor_atom;

   types = NULL;

   n_types = 0;

   pixmap_bytes = 0;

  xdisplay = GDK_DISPLAY_XDISPLAY (gdisplay);

  _wnck_error_trap_push (xdisplay);

  XResQueryClientResources (xdisplay,

                             xid, &n_types,

                             &types);

   XResQueryClientPixmapBytes (xdisplay,

                               xid, &pixmap_bytes);

   _wnck_error_trap_pop (xdisplay);

   usage->pixmap_bytes = pixmap_bytes;

   pixmap_atom = _wnck_atom_get ("PIXMAP");

   window_atom = _wnck_atom_get ("WINDOW");

   gc_atom = _wnck_atom_get ("GC");

   font_atom = _wnck_atom_get ("FONT");

   glyphset_atom = _wnck_atom_get ("GLYPHSET");

   picture_atom = _wnck_atom_get ("PICTURE");

   colormap_entry_atom = _wnck_atom_get ("COLORMAP ENTRY");

   passive_grab_atom = _wnck_atom_get ("PASSIVE GRAB");

   cursor_atom = _wnck_atom_get ("CURSOR");

   i = 0;

   while (i < n_types)

     {

       guint t = types[i].resource_type;

       if (t == pixmap_atom)

         usage->n_pixmaps += types[i].count;

       else if (t == window_atom)

         usage->n_windows += types[i].count;

       else if (t == gc_atom)

         usage->n_gcs += types[i].count;

       else if (t == picture_atom)

         usage->n_pictures += types[i].count;

       else if (t == glyphset_atom)

         usage->n_glyphsets += types[i].count;

       else if (t == font_atom)

         usage->n_fonts += types[i].count;

       else if (t == colormap_entry_atom)

         usage->n_colormap_entries += types[i].count;

       else if (t == passive_grab_atom)

         usage->n_passive_grabs += types[i].count;

       else if (t == cursor_atom)

         usage->n_cursors += types[i].count;

       else

         usage->n_other += types[i].count;

       ++i;

     }

   XFree(types);

   usage->total_bytes_estimate = usage->pixmap_bytes;

   /* FIXME look in the X server source and come up with better

    * answers here. Ideally we change XRes to return a number

    * like this since it can do things like divide the cost of

    * a shared resource among those sharing it.

    */

   usage->total_bytes_estimate += usage->n_windows * 24;

   usage->total_bytes_estimate += usage->n_gcs * 24;

   usage->total_bytes_estimate += usage->n_pictures * 24;

   usage->total_bytes_estimate += usage->n_glyphsets * 24;

   usage->total_bytes_estimate += usage->n_fonts * 1024;

   usage->total_bytes_estimate += usage->n_colormap_entries * 24;

   usage->total_bytes_estimate += usage->n_passive_grabs * 24;

   usage->total_bytes_estimate += usage->n_cursors * 24;

   usage->total_bytes_estimate += usage->n_other * 24;

 }

#else /* HAVE_XRES */

  g_assert_not_reached ();

#endif /* HAVE_XRES */

}

#ifdef HAVE_XRES

static void

wnck_pid_read_resource_usage_free_hash (gpointer data)

{

  g_slice_free (gulong, data);

}

static guint

wnck_gulong_hash (gconstpointer v)

{

  /* FIXME: this is obvioulsy wrong, but nearly 100% of the time, the gulong

   * only contains guint values */

  return *(const guint *) v;

}

static gboolean

wnck_gulong_equal (gconstpointer a,

                   gconstpointer b)

{

  return *((const gulong *) a) == *((const gulong *) b);

}

static gulong

wnck_check_window_for_pid (Screen *screen,

                           Window  win,

                           XID     match_xid,

                           XID     mask)

{

  if ((win & ~mask) == match_xid) {

    return _wnck_get_pid (screen, win);

  }

  return 0;

}

static void

wnck_find_pid_for_resource_r (Display *xdisplay,

                              Screen  *screen,

                              Window   win_top,

                              XID      match_xid,

                              XID      mask,

                              gulong  *xid,

                              gulong  *pid)

{

  Status   qtres;

  int      err;

  Window   dummy;

  Window  *children;

  guint    n_children;

  guint    i;

  gulong   found_pid = 0;

  while (gtk_events_pending ())

    gtk_main_iteration ();

  found_pid = wnck_check_window_for_pid (screen, win_top, match_xid, mask);

  if (found_pid != 0)

    {

      *xid = win_top;

      *pid = found_pid;

    }

  _wnck_error_trap_push (xdisplay);

  qtres = XQueryTree (xdisplay, win_top, &dummy, &dummy,

                      &children, &n_children);

  err = _wnck_error_trap_pop (xdisplay);

  if (!qtres || err != Success)

    return;

  for (i = 0; i < n_children; i++)

    {

      wnck_find_pid_for_resource_r (xdisplay, screen, children[i],

                                    match_xid, mask, xid, pid);

      if (*pid != 0)

	break;

    }

  if (children)

    XFree ((char *)children);

}

struct xresclient_state

{

  XResClient *clients;

  int         n_clients;

  int         next;

  Display    *xdisplay;

  GHashTable *hashtable_pid;

};

static struct xresclient_state xres_state = { NULL, 0, -1, NULL, NULL };

static guint       xres_idleid = 0;

static GHashTable *xres_hashtable = NULL;

static time_t      start_update = 0;

static time_t      end_update = 0;

static guint       xres_removeid = 0;

static void

wnck_pid_read_resource_usage_xres_state_free (gpointer data)

{

  struct xresclient_state *state;

  state = (struct xresclient_state *) data;

  if (state->clients)

    XFree (state->clients);

  state->clients = NULL;

  state->n_clients = 0;

  state->next = -1;

  state->xdisplay = NULL;

  if (state->hashtable_pid)

    g_hash_table_destroy (state->hashtable_pid);

  state->hashtable_pid = NULL;

}

static gboolean

wnck_pid_read_resource_usage_fill_cache (struct xresclient_state *state)

{

  int    i;

  gulong pid;

  gulong xid;

  XID    match_xid;

  if (state->next >= state->n_clients)

    {

      if (xres_hashtable)

        g_hash_table_destroy (xres_hashtable);

      xres_hashtable = state->hashtable_pid;

      state->hashtable_pid = NULL;

      time (&end_update);

      xres_idleid = 0;

      return FALSE;

    }

  match_xid = (state->clients[state->next].resource_base &

               ~state->clients[state->next].resource_mask);

  pid = 0;

  xid = 0;

  for (i = 0; i < ScreenCount (state->xdisplay); i++)

    {

      Screen *screen;

      Window  root;

      screen = ScreenOfDisplay (state->xdisplay, i);

      root = RootWindow (state->xdisplay, i);

      if (root == None)

        continue;

      wnck_find_pid_for_resource_r (state->xdisplay, screen, root, match_xid,

                                    state->clients[state->next].resource_mask,

                                    &xid, &pid;;

      if (pid != 0 && xid != 0)

        break;

    }

  if (pid != 0 && xid != 0)

    {

      gulong *key;

      gulong *value;

      key = g_slice_new (gulong);

      value = g_slice_new (gulong);

      *key = pid;

      *value = xid;

      g_hash_table_insert (state->hashtable_pid, key, value);

    }

  state->next++;

  return TRUE;

}

static void

wnck_pid_read_resource_usage_start_build_cache (GdkDisplay *gdisplay)

{

  Display *xdisplay;

  int      err;

  if (xres_idleid != 0)

    return;

  time (&start_update);

  xdisplay = GDK_DISPLAY_XDISPLAY (gdisplay);

  _wnck_error_trap_push (xdisplay);

  XResQueryClients (xdisplay, &xres_state.n_clients, &xres_state.clients);

  err = _wnck_error_trap_pop (xdisplay);

  if (err != Success)

    return;

  xres_state.next = (xres_state.n_clients > 0) ? 0 : -1;

  xres_state.xdisplay = xdisplay;

  xres_state.hashtable_pid = g_hash_table_new_full (

                                     wnck_gulong_hash,

                                     wnck_gulong_equal,

                                     wnck_pid_read_resource_usage_free_hash,

                                     wnck_pid_read_resource_usage_free_hash);

  xres_idleid = g_idle_add_full (

                        G_PRIORITY_HIGH_IDLE,

                        (GSourceFunc) wnck_pid_read_resource_usage_fill_cache,

                        &xres_state, wnck_pid_read_resource_usage_xres_state_free);

}

static gboolean

wnck_pid_read_resource_usage_destroy_hash_table (gpointer data)

{

  xres_removeid = 0;

  if (xres_hashtable)

    g_hash_table_destroy (xres_hashtable);

  xres_hashtable = NULL;

  return FALSE;

}

#define XRES_UPDATE_RATE_SEC 30

static gboolean

wnck_pid_read_resource_usage_from_cache (GdkDisplay        *gdisplay,

                                         gulong             pid,

                                         WnckResourceUsage *usage)

{

  gboolean  need_rebuild;

  gulong   *xid_p;

  int       cache_validity;

  if (end_update == 0)

    time (&end_update);

  cache_validity = MAX (XRES_UPDATE_RATE_SEC, (end_update - start_update) * 2);

  /* we rebuild the cache if it was never built or if it's old */

  need_rebuild = (xres_hashtable == NULL ||

                  (end_update < time (NULL) - cache_validity));

  if (xres_hashtable)

    {

      /* clear the cache after quite some time, because it might not be used

       * anymore */

      if (xres_removeid != 0)

        g_source_remove (xres_removeid);

      xres_removeid = g_timeout_add_seconds (cache_validity * 2,

                                             wnck_pid_read_resource_usage_destroy_hash_table,

                                             NULL);

    }

  if (need_rebuild)

    wnck_pid_read_resource_usage_start_build_cache (gdisplay);

  if (xres_hashtable)

    xid_p = g_hash_table_lookup (xres_hashtable, &pid;;

  else

    xid_p = NULL;

  if (xid_p)

    {

      wnck_xid_read_resource_usage (gdisplay, *xid_p, usage);

      return TRUE;

    }

  return FALSE;

}

static void

wnck_pid_read_resource_usage_no_cache (GdkDisplay        *gdisplay,

                                       gulong             pid,

                                       WnckResourceUsage *usage)

{

  Display *xdisplay;

  int i;

  xdisplay = GDK_DISPLAY_XDISPLAY (gdisplay);

  i = 0;

  while (i < ScreenCount (xdisplay))

    {

      WnckScreen *screen;

      GList *windows;

      GList *tmp;

      screen = wnck_screen_get (i);

      g_assert (screen != NULL);

      windows = wnck_screen_get_windows (screen);

      tmp = windows;

      while (tmp != NULL)

        {

          if (wnck_window_get_pid (tmp->data) == (int) pid)

            {

              wnck_xid_read_resource_usage (gdisplay,

                                            wnck_window_get_xid (tmp->data),

                                            usage);

              /* stop on first window found */

              return;

            }

          tmp = tmp->next;

        }

      ++i;

    }

}

#endif /* HAVE_XRES */

/**

 * wnck_pid_read_resource_usage:

 * @gdk_display: a <classname>GdkDisplay</classname>.

 * @pid: a process ID.

 * @usage: return location for the X resource usage of the application with

 * process ID @pid.

 *

 * Looks for the X resource usage of the application with process ID @pid on

 * display @gdisplay. If no resource usage can be found, then all fields of

 * @usage are set to 0.

 *

 * In order to find the resource usage of an application that does not have an

 * X window visible to libwnck (panel applets do not have any toplevel windows,

 * for example), wnck_pid_read_resource_usage() walks through the whole tree of

 * X windows. Since this walk is expensive in CPU, a cache is created. This

 * cache is updated in the background. This means there is a non-null

 * probability that no resource usage will be found for an application, even if

 * it is an X client. If this happens, calling wnck_pid_read_resource_usage()

 * again after a few seconds should work.

 *

 * To properly work, this function requires the XRes extension on the X server.

 *

 * Since: 2.6

 */

void

wnck_pid_read_resource_usage (GdkDisplay        *gdisplay,

                              gulong             pid,

                              WnckResourceUsage *usage)

{

  g_return_if_fail (usage != NULL);

  memset (usage, '\0', sizeof (*usage));

  if (wnck_init_resource_usage (gdisplay) == WNCK_EXT_MISSING)

    return;

#ifdef HAVE_XRES

  if (!wnck_pid_read_resource_usage_from_cache (gdisplay, pid, usage))

    /* the cache might not be built, might be outdated or might not contain

     * data for a new X client, so try to fallback to something else */

    wnck_pid_read_resource_usage_no_cache (gdisplay, pid, usage);

#endif /* HAVE_XRES */

}

static WnckClientType client_type = 0;

/**

 * wnck_set_client_type:

 * @ewmh_sourceindication_client_type: a role for the client.

 *

 * Sets the role of the libwnck user.

 *

 * The default role is %WNCK_CLIENT_TYPE_APPLICATION. Therefore, for

 * applications providing some window management features, like pagers or

 * tasklists, it is important to set the role to %WNCK_CLIENT_TYPE_PAGER for

 * libwnck to properly work.

 *

 * Since: 2.14

 */

void

wnck_set_client_type (WnckClientType ewmh_sourceindication_client_type)

{

  /* Clients constantly switching types makes no sense; this should only be

   * set once.

   */

  if (client_type != 0)

    g_critical ("wnck_set_client_type got called multiple times.\n");

  else

    client_type = ewmh_sourceindication_client_type;

}

WnckClientType

_wnck_get_client_type (void)

{

  /* If the type hasn't been set yet, use the default--treat it as a

   * normal application.

   */

  if (client_type == 0)

    client_type = WNCK_CLIENT_TYPE_APPLICATION;

  return client_type;

}

static gsize default_icon_size = WNCK_DEFAULT_ICON_SIZE;

/**

 * wnck_set_default_icon_size:

 * @size: the default size for windows and application standard icons.

 *

 * The default main icon size is %WNCK_DEFAULT_ICON_SIZE. This function allows

 * to change this value.

 *

 * Since: 2.4.6

 */

void

wnck_set_default_icon_size (gsize size)

{

  default_icon_size = size;

}

gsize

_wnck_get_default_icon_size (void)

{

  return default_icon_size;

}

static gsize default_mini_icon_size = WNCK_DEFAULT_MINI_ICON_SIZE;

/**

 * wnck_set_default_mini_icon_size:

 * @size: the default size for windows and application mini icons.

 *

 * The default main icon size is %WNCK_DEFAULT_MINI_ICON_SIZE. This function

 * allows to change this value.

 *

 * Since: 2.4.6

 */

void

wnck_set_default_mini_icon_size (gsize size)

{

  int default_screen;

  WnckScreen *screen;

  GList *l;

  default_mini_icon_size = size;

  default_screen = DefaultScreen (_wnck_get_default_display ());

  screen = _wnck_screen_get_existing (default_screen);

  if (WNCK_IS_SCREEN (screen))

    {

      /* Make applications and icons to reload their icons */

      for (l = wnck_screen_get_windows (screen); l; l = l->next)

        {

          WnckWindow *window = WNCK_WINDOW (l->data);

          WnckApplication *application = wnck_window_get_application (window);

          _wnck_window_load_icons (window);

          if (WNCK_IS_APPLICATION (application))

            _wnck_application_load_icons (application);

        }

    }

}

gsize

_wnck_get_default_mini_icon_size (void)

{

  return default_mini_icon_size;

}

/**

 * _make_gtk_label_bold:

 * @label: The label.

 *

 * Switches the font of label to a bold equivalent.

 **/

void

_make_gtk_label_bold (GtkLabel *label)

{

  GtkStyleContext *context;

  _wnck_ensure_fallback_style ();

  context = gtk_widget_get_style_context (GTK_WIDGET (label));

  gtk_style_context_add_class (context, "wnck-needs-attention");

}

void

_make_gtk_label_normal (GtkLabel *label)

{

  GtkStyleContext *context;

  context = gtk_widget_get_style_context (GTK_WIDGET (label));

  gtk_style_context_remove_class (context, "wnck-needs-attention");

}

#ifdef HAVE_STARTUP_NOTIFICATION

static gboolean

_wnck_util_sn_utf8_validator (const char *str,

                              int         max_len)

{

  return g_utf8_validate (str, max_len, NULL);

}

#endif /* HAVE_STARTUP_NOTIFICATION */

void

_wnck_init (void)

{

  static gboolean done = FALSE;

  if (!done)

    {

      bindtextdomain (GETTEXT_PACKAGE, WNCK_LOCALEDIR);

      bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");

#ifdef HAVE_STARTUP_NOTIFICATION

      sn_set_utf8_validator (_wnck_util_sn_utf8_validator);

#endif /* HAVE_STARTUP_NOTIFICATION */

      done = TRUE;

    }

}

Display *

_wnck_get_default_display (void)

{

  GdkDisplay *display = gdk_display_get_default ();

  /* FIXME: when we fix libwnck to not use the GDK default display, we will

   * need to fix wnckprop accordingly. */

  if (!GDK_IS_X11_DISPLAY (display))

    {

      g_warning ("libwnck is designed to work in X11 only, no valid display found");

      return NULL;

    }

  return GDK_DISPLAY_XDISPLAY (display);

}

/**

 * wnck_shutdown:

 *

 * Makes libwnck stop listening to events and tear down all resources from

 * libwnck. This should be done if you are not going to need the state change

 * notifications for an extended period of time, to avoid wakeups with every

 * key and focus event.

 *

 * After this, all pointers to Wnck object you might still hold are invalid.

 *

 * Due to the fact that 

 * linkend="getting-started.pitfalls.memory-management">Wnck objects are all

 * owned by libwnck</link>, users of this API through introspection should be

 * extremely careful: they must explicitly clear variables referencing objects

 * before this call. Failure to do so might result in crashes.

 *

 * Since: 3.4

 */

void

wnck_shutdown (void)

{

  _wnck_event_filter_shutdown ();

  /* Warning: this is hacky :-)

   *

   * Shutting down all WnckScreen objects will automatically unreference (and

   * finalize) all WnckWindow objects, but not the WnckClassGroup and

   * WnckApplication objects.

   * Therefore we need to manually shut down all WnckClassGroup and

   * WnckApplication objects first, since they reference the WnckScreen they're

   * on.

   * On the other side, shutting down the WnckScreen objects will results in

   * all WnckWindow objects getting unreferenced and finalized, and must

   * actually be done before shutting down global WnckWindow structures

   * (because the WnckScreen has a list of WnckWindow that will get mis-used

   * otherwise). */

  _wnck_class_group_shutdown_all ();

  _wnck_application_shutdown_all ();

  _wnck_screen_shutdown_all ();

  _wnck_window_shutdown_all ();

#ifdef HAVE_XRES

  if (xres_removeid != 0)

    g_source_remove (xres_removeid);

  xres_removeid = 0;

  wnck_pid_read_resource_usage_destroy_hash_table (NULL);

#endif

}

void

_wnck_ensure_fallback_style (void)

{

  static gboolean css_loaded = FALSE;

  GtkCssProvider *provider;

  guint priority;

  if (css_loaded)

    return;

  provider = gtk_css_provider_new ();

  gtk_css_provider_load_from_resource (provider, "/org/gnome/libwnck/wnck.css");

  priority = GTK_STYLE_PROVIDER_PRIORITY_FALLBACK;

  gtk_style_context_add_provider_for_screen (gdk_screen_get_default (),

                                             GTK_STYLE_PROVIDER (provider),

                                             priority);

  g_object_unref (provider);

  css_loaded = TRUE;

}