/*

 * Copyright © 2001, 2007 Red Hat, Inc.

 *

 * Permission to use, copy, modify, distribute, and sell this software and its

 * documentation for any purpose is hereby granted without fee, provided that

 * the above copyright notice appear in all copies and that both that

 * copyright notice and this permission notice appear in supporting

 * documentation, and that the name of Red Hat not be used in advertising or

 * publicity pertaining to distribution of the software without specific,

 * written prior permission.  Red Hat makes no representations about the

 * suitability of this software for any purpose.  It is provided "as is"

 * without express or implied warranty.

 *

 * RED HAT DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL

 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL RED HAT

 * BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES

 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION

 * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN 

 * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

 *

 * Author:  Owen Taylor, Red Hat, Inc.

 */

#include "config.h"

#include <limits.h>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <X11/Xlib.h>

#include <X11/Xmd.h>		/* For CARD16 */

#include "xsettings-client.h"

struct _XSettingsClient

{

  Display *display;

  int screen;

  XSettingsNotifyFunc notify;

  XSettingsWatchFunc watch;

  void *cb_data;

  XSettingsGrabFunc grab;

  XSettingsGrabFunc ungrab;

  Window manager_window;

  Atom manager_atom;

  Atom selection_atom;

  Atom xsettings_atom;

  XSettingsList *settings;

};

static void

notify_changes (XSettingsClient *client,

		XSettingsList   *old_list)

{

  XSettingsList *old_iter = old_list;

  XSettingsList *new_iter = client->settings;

  if (!client->notify)

    return;

  while (old_iter || new_iter)

    {

      int cmp;

      if (old_iter && new_iter)

	cmp = strcmp (old_iter->setting->name, new_iter->setting->name);

      else if (old_iter)

	cmp = -1;

      else

	cmp = 1;

      if (cmp < 0)

	{

	  client->notify (old_iter->setting->name,

			  XSETTINGS_ACTION_DELETED,

			  NULL,

			  client->cb_data);

	}

      else if (cmp == 0)

	{

	  if (!xsettings_setting_equal (old_iter->setting,

					new_iter->setting))

	    client->notify (old_iter->setting->name,

			    XSETTINGS_ACTION_CHANGED,

			    new_iter->setting,

			    client->cb_data);

	}

      else

	{

	  client->notify (new_iter->setting->name,

			  XSETTINGS_ACTION_NEW,

			  new_iter->setting,

			  client->cb_data);

	}

      if (old_iter)

	old_iter = old_iter->next;

      if (new_iter)

	new_iter = new_iter->next;

    }

}

static int

ignore_errors (Display *display, XErrorEvent *event)

{

  return True;

}

static char local_byte_order = '\0';

#define BYTES_LEFT(buffer) ((buffer)->data + (buffer)->len - (buffer)->pos)

static XSettingsResult

fetch_card16 (XSettingsBuffer *buffer,

	      CARD16          *result)

{

  CARD16 x;

  if (BYTES_LEFT (buffer) < 2)

    return XSETTINGS_ACCESS;

  x = *(CARD16 *)buffer->pos;

  buffer->pos += 2;

  if (buffer->byte_order == local_byte_order)

    *result = x;

  else

    *result = (x << 8) | (x >> 8);

  return XSETTINGS_SUCCESS;

}

static XSettingsResult

fetch_ushort (XSettingsBuffer *buffer,

	      unsigned short  *result) 

{

  CARD16 x;

  XSettingsResult r;  

  r = fetch_card16 (buffer, &x);

  if (r == XSETTINGS_SUCCESS)

    *result = x;

  return r;

}

static XSettingsResult

fetch_card32 (XSettingsBuffer *buffer,

	      CARD32          *result)

{

  CARD32 x;

  if (BYTES_LEFT (buffer) < 4)

    return XSETTINGS_ACCESS;

  x = *(CARD32 *)buffer->pos;

  buffer->pos += 4;

  if (buffer->byte_order == local_byte_order)

    *result = x;

  else

    *result = (x << 24) | ((x & 0xff00) << 8) | ((x & 0xff0000) >> 8) | (x >> 24);

  return XSETTINGS_SUCCESS;

}

static XSettingsResult

fetch_card8 (XSettingsBuffer *buffer,

	     CARD8           *result)

{

  if (BYTES_LEFT (buffer) < 1)

    return XSETTINGS_ACCESS;

  *result = *(CARD8 *)buffer->pos;

  buffer->pos += 1;

  return XSETTINGS_SUCCESS;

}

#define XSETTINGS_PAD(n,m) ((n + m - 1) & (~(m-1)))

static XSettingsList *

parse_settings (unsigned char *data,

		size_t         len)

{

  XSettingsBuffer buffer;

  XSettingsResult result = XSETTINGS_SUCCESS;

  XSettingsList *settings = NULL;

  CARD32 serial;

  CARD32 n_entries;

  CARD32 i;

  XSettingsSetting *setting = NULL;

  local_byte_order = xsettings_byte_order ();

  buffer.pos = buffer.data = data;

  buffer.len = len;

  result = fetch_card8 (&buffer, (unsigned char *)&buffer.byte_order);

  if (buffer.byte_order != MSBFirst &&

      buffer.byte_order != LSBFirst)

    {

      fprintf (stderr, "Invalid byte order in XSETTINGS property\n");

      result = XSETTINGS_FAILED;

      goto out;

    }

  buffer.pos += 3;

  result = fetch_card32 (&buffer, &serial);

  if (result != XSETTINGS_SUCCESS)

    goto out;

  result = fetch_card32 (&buffer, &n_entries);

  if (result != XSETTINGS_SUCCESS)

    goto out;

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

    {

      CARD8 type;

      CARD16 name_len;

      CARD32 v_int;

      size_t pad_len;

      result = fetch_card8 (&buffer, &type);

      if (result != XSETTINGS_SUCCESS)

	goto out;

      buffer.pos += 1;

      result = fetch_card16 (&buffer, &name_len);

      if (result != XSETTINGS_SUCCESS)

	goto out;

      pad_len = XSETTINGS_PAD(name_len, 4);

      if (BYTES_LEFT (&buffer) < pad_len)

	{

	  result = XSETTINGS_ACCESS;

	  goto out;

	}

      setting = malloc (sizeof *setting);

      if (!setting)

	{

	  result = XSETTINGS_NO_MEM;

	  goto out;

	}

      setting->type = XSETTINGS_TYPE_INT; /* No allocated memory */

      setting->name = malloc (name_len + 1);

      if (!setting->name)

	{

	  result = XSETTINGS_NO_MEM;

	  goto out;

	}

      memcpy (setting->name, buffer.pos, name_len);

      setting->name[name_len] = '\0';

      buffer.pos += pad_len;

      result = fetch_card32 (&buffer, &v_int);

      if (result != XSETTINGS_SUCCESS)

	goto out;

      setting->last_change_serial = v_int;

      switch (type)

	{

	case XSETTINGS_TYPE_INT:

	  result = fetch_card32 (&buffer, &v_int);

	  if (result != XSETTINGS_SUCCESS)

	    goto out;

	  setting->data.v_int = (INT32)v_int;

	  break;

	case XSETTINGS_TYPE_STRING:

	  result = fetch_card32 (&buffer, &v_int);

	  if (result != XSETTINGS_SUCCESS)

	    goto out;

	  pad_len = XSETTINGS_PAD (v_int, 4);

	  if (v_int + 1 == 0 || /* Guard against wrap-around */

	      BYTES_LEFT (&buffer) < pad_len)

	    {

	      result = XSETTINGS_ACCESS;

	      goto out;

	    }

	  setting->data.v_string = malloc (v_int + 1);

	  if (!setting->data.v_string)

	    {

	      result = XSETTINGS_NO_MEM;

	      goto out;

	    }

	  memcpy (setting->data.v_string, buffer.pos, v_int);

	  setting->data.v_string[v_int] = '\0';

	  buffer.pos += pad_len;

	  break;

	case XSETTINGS_TYPE_COLOR:

	  result = fetch_ushort (&buffer, &setting->data.v_color.red);

	  if (result != XSETTINGS_SUCCESS)

	    goto out;

	  result = fetch_ushort (&buffer, &setting->data.v_color.green);

	  if (result != XSETTINGS_SUCCESS)

	    goto out;

	  result = fetch_ushort (&buffer, &setting->data.v_color.blue);

	  if (result != XSETTINGS_SUCCESS)

	    goto out;

	  result = fetch_ushort (&buffer, &setting->data.v_color.alpha);

	  if (result != XSETTINGS_SUCCESS)

	    goto out;

	  break;

	default:

	  /* Quietly ignore unknown types */

	  break;

	}

      setting->type = type;

      result = xsettings_list_insert (&settings, setting);

      if (result != XSETTINGS_SUCCESS)

	goto out;

      setting = NULL;

    }

 out:

  if (result != XSETTINGS_SUCCESS)

    {

      switch (result)

	{

	case XSETTINGS_NO_MEM:

	  fprintf(stderr, "Out of memory reading XSETTINGS property\n");

	  break;

	case XSETTINGS_ACCESS:

	  fprintf(stderr, "Invalid XSETTINGS property (read off end)\n");

	  break;

	case XSETTINGS_DUPLICATE_ENTRY:

	  fprintf (stderr, "Duplicate XSETTINGS entry for '%s'\n", setting->name);

	case XSETTINGS_FAILED:

	case XSETTINGS_SUCCESS:

	case XSETTINGS_NO_ENTRY:

	  break;

	}

      if (setting)

	xsettings_setting_free (setting);

      xsettings_list_free (settings);

      settings = NULL;

    }

  return settings;

}

static void

read_settings (XSettingsClient *client)

{

  Atom type;

  int format;

  unsigned long n_items;

  unsigned long bytes_after;

  unsigned char *data;

  int result;

  int (*old_handler) (Display *, XErrorEvent *);

  XSettingsList *old_list = client->settings;

  client->settings = NULL;

  if (client->manager_window)

    {

      old_handler = XSetErrorHandler (ignore_errors);

      result = XGetWindowProperty (client->display, client->manager_window,

				   client->xsettings_atom, 0, LONG_MAX,

				   False, client->xsettings_atom,

				   &type, &format, &n_items, &bytes_after, &data);

      XSetErrorHandler (old_handler);

      if (result == Success && type != None)

	{

	  if (type != client->xsettings_atom)

	    {

	      fprintf (stderr, "Invalid type for XSETTINGS property");

	    }

	  else if (format != 8)

	    {

	      fprintf (stderr, "Invalid format for XSETTINGS property %d", format);

	    }

	  else

	    client->settings = parse_settings (data, n_items);

	  XFree (data);

	}

    }

  notify_changes (client, old_list);

  xsettings_list_free (old_list);

}

static void

add_events (Display *display,

	    Window   window,

	    long     mask)

{

  XWindowAttributes attr;

  XGetWindowAttributes (display, window, &attr);

  XSelectInput (display, window, attr.your_event_mask | mask);

}

static void

check_manager_window (XSettingsClient *client)

{

  if (client->manager_window && client->watch)

    client->watch (client->manager_window, False, 0, client->cb_data);

  if (client->grab)

    client->grab (client->display);

  else

    XGrabServer (client->display);

  client->manager_window = XGetSelectionOwner (client->display,

					       client->selection_atom);

  if (client->manager_window)

    XSelectInput (client->display, client->manager_window,

		  PropertyChangeMask | StructureNotifyMask);

  if (client->ungrab)

    client->ungrab (client->display);

  else

    XUngrabServer (client->display);

  XFlush (client->display);

  if (client->manager_window && client->watch)

    {

      if (!client->watch (client->manager_window, True, 

			  PropertyChangeMask | StructureNotifyMask,

			  client->cb_data))

	{

	  /* Inability to watch the window probably means that it was destroyed

	   * after we ungrabbed

	   */

	  client->manager_window = None;

	  return;

	}

    }

  read_settings (client);

}

XSettingsClient *

xsettings_client_new (Display             *display,

		      int                  screen,

		      XSettingsNotifyFunc  notify,

		      XSettingsWatchFunc   watch,

		      void                *cb_data)

{

  return xsettings_client_new_with_grab_funcs (display, screen, notify, watch, cb_data,

                                               NULL, NULL);

}

XSettingsClient *

xsettings_client_new_with_grab_funcs (Display             *display,

		                      int                  screen,

		                      XSettingsNotifyFunc  notify,

		                      XSettingsWatchFunc   watch,

		                      void                *cb_data,

		                      XSettingsGrabFunc    grab,

		                      XSettingsGrabFunc    ungrab)

{

  XSettingsClient *client;

  char buffer[256];

  char *atom_names[3];

  Atom atoms[3];

  client = malloc (sizeof *client);

  if (!client)

    return NULL;

  client->display = display;

  client->screen = screen;

  client->notify = notify;

  client->watch = watch;

  client->cb_data = cb_data;

  client->grab = grab;

  client->ungrab = ungrab;

  client->manager_window = None;

  client->settings = NULL;

  sprintf(buffer, "_XSETTINGS_S%d", screen);

  atom_names[0] = buffer;

  atom_names[1] = "_XSETTINGS_SETTINGS";

  atom_names[2] = "MANAGER";

#ifdef HAVE_XINTERNATOMS

  XInternAtoms (display, atom_names, 3, False, atoms);

#else

  atoms[0] = XInternAtom (display, atom_names[0], False);

  atoms[1] = XInternAtom (display, atom_names[1], False);

  atoms[2] = XInternAtom (display, atom_names[2], False);

#endif

  client->selection_atom = atoms[0];

  client->xsettings_atom = atoms[1];

  client->manager_atom = atoms[2];

  /* Select on StructureNotify so we get MANAGER events

   */

  add_events (display, RootWindow (display, screen), StructureNotifyMask);

  if (client->watch)

    client->watch (RootWindow (display, screen), True, StructureNotifyMask,

		   client->cb_data);

  check_manager_window (client);

  return client;

}

void

xsettings_client_set_grab_func   (XSettingsClient      *client,

				  XSettingsGrabFunc     grab)

{

  client->grab = grab;

}

void

xsettings_client_set_ungrab_func (XSettingsClient      *client,

				  XSettingsGrabFunc     ungrab)

{

  client->ungrab = ungrab;

}

void

xsettings_client_destroy (XSettingsClient *client)

{

  if (client->watch)

    client->watch (RootWindow (client->display, client->screen),

		   False, 0, client->cb_data);

  if (client->manager_window && client->watch)

    client->watch (client->manager_window, False, 0, client->cb_data);

  xsettings_list_free (client->settings);

  free (client);

}

XSettingsResult

xsettings_client_get_setting (XSettingsClient   *client,

			      const char        *name,

			      XSettingsSetting **setting)

{

  XSettingsSetting *search = xsettings_list_lookup (client->settings, name);

  if (search)

    {

      *setting = xsettings_setting_copy (search);

      return *setting ? XSETTINGS_SUCCESS : XSETTINGS_NO_MEM;

    }

  else

    return XSETTINGS_NO_ENTRY;

}

Bool

xsettings_client_process_event (XSettingsClient *client,

				XEvent          *xev)

{

  /* The checks here will not unlikely cause us to reread

   * the properties from the manager window a number of

   * times when the manager changes from A->B. But manager changes

   * are going to be pretty rare.

   */

  if (xev->xany.window == RootWindow (client->display, client->screen))

    {

      if (xev->xany.type == ClientMessage &&

	  xev->xclient.message_type == client->manager_atom &&

	  xev->xclient.data.l[1] == client->selection_atom)

	{

	  check_manager_window (client);

	  return True;

	}

    }

  else if (xev->xany.window == client->manager_window)

    {

      if (xev->xany.type == DestroyNotify)

	{

	  check_manager_window (client);

          /* let GDK do its cleanup */

	  return False; 

	}

      else if (xev->xany.type == PropertyNotify)

	{

	  read_settings (client);

	  return True;

	}

    }

  return False;

}