/*
 * Various ICCCM related functions.
 *
 * This is ALL the code involving anything ICCCM related. for both WM and
 * client.
 */

#ifdef HAVE_CONFIG_H
# include <config.h>
#endif /* ifdef HAVE_CONFIG_H */

#include <stdlib.h>
#include <string.h>

#include "Ecore.h"
#include "ecore_x_private.h"
#include "Ecore_X.h"
#include "Ecore_X_Atoms.h"

EAPI void
ecore_x_icccm_init(void)
{
   LOGFN(__FILE__, __LINE__, __FUNCTION__);
}

EAPI void
ecore_x_icccm_state_set(Ecore_X_Window win,
                        Ecore_X_Window_State_Hint state)
{
   unsigned long c[2];

   LOGFN(__FILE__, __LINE__, __FUNCTION__);
   if (state == ECORE_X_WINDOW_STATE_HINT_WITHDRAWN)
     c[0] = WithdrawnState;
   else if (state == ECORE_X_WINDOW_STATE_HINT_NORMAL)
     c[0] = NormalState;
   else if (state == ECORE_X_WINDOW_STATE_HINT_ICONIC)
     c[0] = IconicState;

   c[1] = None;
   XChangeProperty(_ecore_x_disp, win, ECORE_X_ATOM_WM_STATE,
                   ECORE_X_ATOM_WM_STATE, 32, PropModeReplace,
                   (unsigned char *)c, 2);
}

EAPI Ecore_X_Window_State_Hint
ecore_x_icccm_state_get(Ecore_X_Window win)
{
   unsigned char *prop_ret = NULL;
   Atom type_ret;
   unsigned long bytes_after, num_ret;
   int format_ret;
   Ecore_X_Window_State_Hint hint;

   LOGFN(__FILE__, __LINE__, __FUNCTION__);
   hint = ECORE_X_WINDOW_STATE_HINT_NONE;
   XGetWindowProperty(_ecore_x_disp, win, ECORE_X_ATOM_WM_STATE,
                      0, 0x7fffffff, False, ECORE_X_ATOM_WM_STATE,
                      &type_ret, &format_ret, &num_ret, &bytes_after,
                      &prop_ret);
   if ((prop_ret) && (num_ret == 2))
     {
        if (prop_ret[0] == WithdrawnState)
          hint = ECORE_X_WINDOW_STATE_HINT_WITHDRAWN;
        else if (prop_ret[0] == NormalState)
          hint = ECORE_X_WINDOW_STATE_HINT_NORMAL;
        else if (prop_ret[0] == IconicState)
          hint = ECORE_X_WINDOW_STATE_HINT_ICONIC;
     }

   if (prop_ret)
     XFree(prop_ret);

   return hint;
}

EAPI void
ecore_x_icccm_delete_window_send(Ecore_X_Window win,
                                 Ecore_X_Time t)
{
   LOGFN(__FILE__, __LINE__, __FUNCTION__);
   ecore_x_client_message32_send(win, ECORE_X_ATOM_WM_PROTOCOLS,
                                 ECORE_X_EVENT_MASK_NONE,
                                 ECORE_X_ATOM_WM_DELETE_WINDOW,
                                 t, 0, 0, 0);
}

EAPI void
ecore_x_icccm_take_focus_send(Ecore_X_Window win,
                              Ecore_X_Time t)
{
   LOGFN(__FILE__, __LINE__, __FUNCTION__);
   ecore_x_client_message32_send(win, ECORE_X_ATOM_WM_PROTOCOLS,
                                 ECORE_X_EVENT_MASK_NONE,
                                 ECORE_X_ATOM_WM_TAKE_FOCUS,
                                 t, 0, 0, 0);
}

EAPI void
ecore_x_icccm_save_yourself_send(Ecore_X_Window win,
                                 Ecore_X_Time t)
{
   LOGFN(__FILE__, __LINE__, __FUNCTION__);
   ecore_x_client_message32_send(win, ECORE_X_ATOM_WM_PROTOCOLS,
                                 ECORE_X_EVENT_MASK_NONE,
                                 ECORE_X_ATOM_WM_SAVE_YOURSELF,
                                 t, 0, 0, 0);
}

EAPI void
ecore_x_icccm_move_resize_send(Ecore_X_Window win,
                               int x,
                               int y,
                               int w,
                               int h)
{
   XEvent ev;

   LOGFN(__FILE__, __LINE__, __FUNCTION__);
   ev.type = ConfigureNotify;
   ev.xconfigure.display = _ecore_x_disp;
   ev.xconfigure.event = win;
   ev.xconfigure.window = win;
   ev.xconfigure.x = x;
   ev.xconfigure.y = y;
   ev.xconfigure.width = w;
   ev.xconfigure.height = h;
   ev.xconfigure.border_width = 0;
   ev.xconfigure.above = None;
   ev.xconfigure.override_redirect = False;
   XSendEvent(_ecore_x_disp, win, False, StructureNotifyMask, &ev);
}

EAPI void
ecore_x_icccm_hints_set(Ecore_X_Window win,
                        Eina_Bool accepts_focus,
                        Ecore_X_Window_State_Hint initial_state,
                        Ecore_X_Pixmap icon_pixmap,
                        Ecore_X_Pixmap icon_mask,
                        Ecore_X_Window icon_window,
                        Ecore_X_Window window_group,
                        Eina_Bool is_urgent)
{
   XWMHints *hints;

   hints = XAllocWMHints();
   if (!hints)
     return;

   LOGFN(__FILE__, __LINE__, __FUNCTION__);
   hints->flags = InputHint | StateHint;
   hints->input = accepts_focus;
   if (initial_state == ECORE_X_WINDOW_STATE_HINT_WITHDRAWN)
     hints->initial_state = WithdrawnState;
   else if (initial_state == ECORE_X_WINDOW_STATE_HINT_NORMAL)
     hints->initial_state = NormalState;
   else if (initial_state == ECORE_X_WINDOW_STATE_HINT_ICONIC)
     hints->initial_state = IconicState;

   if (icon_pixmap != 0)
     {
        hints->icon_pixmap = icon_pixmap;
        hints->flags |= IconPixmapHint;
     }

   if (icon_mask != 0)
     {
        hints->icon_mask = icon_mask;
        hints->flags |= IconMaskHint;
     }

   if (icon_window != 0)
     {
        hints->icon_window = icon_window;
        hints->flags |= IconWindowHint;
     }

   if (window_group != 0)
     {
        hints->window_group = window_group;
        hints->flags |= WindowGroupHint;
     }

   if (is_urgent)
     hints->flags |= XUrgencyHint;

   XSetWMHints(_ecore_x_disp, win, hints);
   XFree(hints);
}

EAPI Eina_Bool
ecore_x_icccm_hints_get(Ecore_X_Window win,
                        Eina_Bool *accepts_focus,
                        Ecore_X_Window_State_Hint *initial_state,
                        Ecore_X_Pixmap *icon_pixmap,
                        Ecore_X_Pixmap *icon_mask,
                        Ecore_X_Window *icon_window,
                        Ecore_X_Window *window_group,
                        Eina_Bool *is_urgent)
{
   XWMHints *hints;

   LOGFN(__FILE__, __LINE__, __FUNCTION__);
   if (accepts_focus)
     *accepts_focus = EINA_TRUE;

   if (initial_state)
     *initial_state = ECORE_X_WINDOW_STATE_HINT_NORMAL;

   if (icon_pixmap)
     *icon_pixmap = 0;

   if (icon_mask)
     *icon_mask = 0;

   if (icon_window)
     *icon_window = 0;

   if (window_group)
     *window_group = 0;

   if (is_urgent)
     *is_urgent = EINA_FALSE;

   hints = XGetWMHints(_ecore_x_disp, win);
   if (hints)
     {
        if ((hints->flags & InputHint) && (accepts_focus))
          {
             if (hints->input)
               *accepts_focus = EINA_TRUE;
             else
               *accepts_focus = EINA_FALSE;
          }

        if ((hints->flags & StateHint) && (initial_state))
          {
             if (hints->initial_state == WithdrawnState)
               *initial_state = ECORE_X_WINDOW_STATE_HINT_WITHDRAWN;
             else if (hints->initial_state == NormalState)
               *initial_state = ECORE_X_WINDOW_STATE_HINT_NORMAL;
             else if (hints->initial_state == IconicState)
               *initial_state = ECORE_X_WINDOW_STATE_HINT_ICONIC;
          }

        if ((hints->flags & IconPixmapHint) && (icon_pixmap))
          *icon_pixmap = hints->icon_pixmap;

        if ((hints->flags & IconMaskHint) && (icon_mask))
          *icon_mask = hints->icon_mask;

        if ((hints->flags & IconWindowHint) && (icon_window))
          *icon_window = hints->icon_window;

        if ((hints->flags & WindowGroupHint) && (window_group))
          *window_group = hints->window_group;

        if ((hints->flags & XUrgencyHint) && (is_urgent))
          *is_urgent = EINA_TRUE;

        XFree(hints);
        return EINA_TRUE;
     }

   return EINA_FALSE;
}

EAPI void
ecore_x_icccm_size_pos_hints_set(Ecore_X_Window win,
                                 Eina_Bool request_pos,
                                 Ecore_X_Gravity gravity,
                                 int min_w,
                                 int min_h,
                                 int max_w,
                                 int max_h,
                                 int base_w,
                                 int base_h,
                                 int step_x,
                                 int step_y,
                                 double min_aspect,
                                 double max_aspect)
{
   XSizeHints hint;
   long mask;

   LOGFN(__FILE__, __LINE__, __FUNCTION__);
   if (!XGetWMNormalHints(_ecore_x_disp, win, &hint, &mask))
     memset(&hint, 0, sizeof(XSizeHints));

   hint.flags = 0;
   if (request_pos)
     hint.flags |= USPosition;

   if (gravity != ECORE_X_GRAVITY_NW)
     {
        hint.flags |= PWinGravity;
        hint.win_gravity = gravity;
     }

   if ((min_w > 0) || (min_h > 0))
     {
        hint.flags |= PMinSize;
        hint.min_width = min_w;
        hint.min_height = min_h;
     }

   if ((max_w > 0) || (max_h > 0))
     {
        hint.flags |= PMaxSize;
        hint.max_width = max_w;
        hint.max_height = max_h;
     }

   if ((base_w > 0) || (base_h > 0))
     {
        hint.flags |= PBaseSize;
        hint.base_width = base_w;
        hint.base_height = base_h;
     }

   if ((step_x > 1) || (step_y > 1))
     {
        hint.flags |= PResizeInc;
        hint.width_inc = step_x;
        hint.height_inc = step_y;
     }

   if ((min_aspect > 0.0) || (max_aspect > 0.0))
     {
        hint.flags |= PAspect;
        hint.min_aspect.x = min_aspect * 10000;
        hint.min_aspect.y = 10000;
        hint.max_aspect.x = max_aspect * 10000;
        hint.max_aspect.y = 10000;
     }

   XSetWMNormalHints(_ecore_x_disp, win, &hint);
}

EAPI Eina_Bool
ecore_x_icccm_size_pos_hints_get(Ecore_X_Window win,
                                 Eina_Bool *request_pos,
                                 Ecore_X_Gravity *gravity,
                                 int *min_w,
                                 int *min_h,
                                 int *max_w,
                                 int *max_h,
                                 int *base_w,
                                 int *base_h,
                                 int *step_x,
                                 int *step_y,
                                 double *min_aspect,
                                 double *max_aspect)
{
   XSizeHints hint;
   long mask;

   int minw = 0, minh = 0;
   int maxw = 32767, maxh = 32767;
   int basew = -1, baseh = -1;
   int stepx = -1, stepy = -1;
   double mina = 0.0, maxa = 0.0;

   LOGFN(__FILE__, __LINE__, __FUNCTION__);
   if (!XGetWMNormalHints(_ecore_x_disp, win, &hint, &mask))
     return EINA_FALSE;

   if ((hint.flags & USPosition) || ((hint.flags & PPosition)))
     {
        if (request_pos)
          *request_pos = EINA_TRUE;
     }
   else if (request_pos)
     *request_pos = EINA_FALSE;

   if (hint.flags & PWinGravity)
     {
        if (gravity)
          *gravity = hint.win_gravity;
     }
   else if (gravity)
     *gravity = ECORE_X_GRAVITY_NW;

   if (hint.flags & PMinSize)
     {
        minw = hint.min_width;
        minh = hint.min_height;
     }

   if (hint.flags & PMaxSize)
     {
        maxw = hint.max_width;
        maxh = hint.max_height;
        if (maxw < minw)
          maxw = minw;

        if (maxh < minh)
          maxh = minh;
     }

   if (hint.flags & PBaseSize)
     {
        basew = hint.base_width;
        baseh = hint.base_height;
        if (basew > minw)
          minw = basew;

        if (baseh > minh)
          minh = baseh;
     }

   if (hint.flags & PResizeInc)
     {
        stepx = hint.width_inc;
        stepy = hint.height_inc;
        if (stepx < 1)
          stepx = 1;

        if (stepy < 1)
          stepy = 1;
     }

   if (hint.flags & PAspect)
     {
        if (hint.min_aspect.y > 0)
          mina = ((double)hint.min_aspect.x) / ((double)hint.min_aspect.y);

        if (hint.max_aspect.y > 0)
          maxa = ((double)hint.max_aspect.x) / ((double)hint.max_aspect.y);
     }

   if (min_w)
     *min_w = minw;

   if (min_h)
     *min_h = minh;

   if (max_w)
     *max_w = maxw;

   if (max_h)
     *max_h = maxh;

   if (base_w)
     *base_w = basew;

   if (base_h)
     *base_h = baseh;

   if (step_x)
     *step_x = stepx;

   if (step_y)
     *step_y = stepy;

   if (min_aspect)
     *min_aspect = mina;

   if (max_aspect)
     *max_aspect = maxa;

   return EINA_TRUE;
}

EAPI void
ecore_x_icccm_title_set(Ecore_X_Window win,
                        const char *t)
{
   char *list[1];
   XTextProperty xprop;
   int ret;

   if (!t)
     return;

   LOGFN(__FILE__, __LINE__, __FUNCTION__);
   xprop.value = NULL;
#ifdef X_HAVE_UTF8_STRING
   list[0] = strdup(t);
   ret =
     Xutf8TextListToTextProperty(_ecore_x_disp, list, 1, XUTF8StringStyle,
                                 &xprop);
#else /* ifdef X_HAVE_UTF8_STRING */
   list[0] = strdup(t);
   ret =
     XmbTextListToTextProperty(_ecore_x_disp, list, 1, XStdICCTextStyle,
                               &xprop);
#endif /* ifdef X_HAVE_UTF8_STRING */
   if (ret >= Success)
     {
        XSetWMName(_ecore_x_disp, win, &xprop);
        if (xprop.value)
          XFree(xprop.value);
     }
   else if (XStringListToTextProperty(list, 1, &xprop) >= Success)
     {
        XSetWMName(_ecore_x_disp, win, &xprop);
        if (xprop.value)
          XFree(xprop.value);
     }

   free(list[0]);
}

EAPI char *
ecore_x_icccm_title_get(Ecore_X_Window win)
{
   XTextProperty xprop;

   LOGFN(__FILE__, __LINE__, __FUNCTION__);
   xprop.value = NULL;
   if (XGetWMName(_ecore_x_disp, win, &xprop) >= Success)
     {
        if (xprop.value)
          {
             char **list = NULL;
             char *t = NULL;
             int num = 0;
             int ret;

             if (xprop.encoding == ECORE_X_ATOM_UTF8_STRING)
               t = strdup((char *)xprop.value);
             else
               {
                  /* convert to utf8 */
#ifdef X_HAVE_UTF8_STRING
                  ret = Xutf8TextPropertyToTextList(_ecore_x_disp, &xprop,
                                                    &list, &num);
#else /* ifdef X_HAVE_UTF8_STRING */
                  ret = XmbTextPropertyToTextList(_ecore_x_disp, &xprop,
                                                  &list, &num);
#endif /* ifdef X_HAVE_UTF8_STRING */

                  if ((ret == XLocaleNotSupported) ||
                      (ret == XNoMemory) || (ret == XConverterNotFound))
                    t = strdup((char *)xprop.value);
                  else if ((ret >= Success) && (num > 0))
                    t = strdup(list[0]);

                  if (list)
                    XFreeStringList(list);
               }

             if (xprop.value)
               XFree(xprop.value);

             return t;
          }
     }

   return NULL;
}

/**
 * Set protocol atoms explicitly
 * @param win The Window
 * @param protos An array of protocol atoms
 * @param num the number of members of the array
 */
EAPI void
ecore_x_icccm_protocol_atoms_set(Ecore_X_Window win,
                                 Ecore_X_Atom *protos,
                                 int num)
{
   LOGFN(__FILE__, __LINE__, __FUNCTION__);
   if (num > 0)
     XSetWMProtocols(_ecore_x_disp, win, (Atom *)(protos), num);
   else
     XDeleteProperty(_ecore_x_disp, win, ECORE_X_ATOM_WM_PROTOCOLS);
}

/**
 * Set or unset a wm protocol property.
 * @param win The Window
 * @param protocol The protocol to enable/disable
 * @param on On/Off
 */
EAPI void
ecore_x_icccm_protocol_set(Ecore_X_Window win,
                           Ecore_X_WM_Protocol protocol,
                           Eina_Bool on)
{
   Atom *protos = NULL;
   Atom proto;
   int protos_count = 0;
   int already_set = 0;
   int i;

   /* Check for invalid values */
   if (protocol >= ECORE_X_WM_PROTOCOL_NUM)
     return;

   LOGFN(__FILE__, __LINE__, __FUNCTION__);
   proto = _ecore_x_atoms_wm_protocols[protocol];

   if (!XGetWMProtocols(_ecore_x_disp, win, &protos, &protos_count))
     {
        protos = NULL;
        protos_count = 0;
     }

   for (i = 0; i < protos_count; i++)
     {
        if (protos[i] == proto)
          {
             already_set = 1;
             break;
          }
     }

   if (on)
     {
        Atom *new_protos = NULL;

        if (already_set)
          goto leave;

        new_protos = malloc((protos_count + 1) * sizeof(Atom));
        if (!new_protos)
          goto leave;

        for (i = 0; i < protos_count; i++)
          new_protos[i] = protos[i];
        new_protos[protos_count] = proto;
        XSetWMProtocols(_ecore_x_disp, win, new_protos, protos_count + 1);
        free(new_protos);
     }
   else
     {
        if (!already_set)
          goto leave;

        for (i = 0; i < protos_count; i++)
          {
             if (protos[i] == proto)
               {
                  int j;

                  for (j = i + 1; j < protos_count; j++)
                    protos[j - 1] = protos[j];
                  if (protos_count > 1)
                    XSetWMProtocols(_ecore_x_disp, win, protos,
                                    protos_count - 1);
                  else
                    XDeleteProperty(_ecore_x_disp, win,
                                    ECORE_X_ATOM_WM_PROTOCOLS);

                  goto leave;
               }
          }
     }

leave:
   if (protos)
     XFree(protos);
}

/**
 * Determines whether a protocol is set for a window.
 * @param win The Window
 * @param protocol The protocol to query
 * @return 1 if the protocol is set, else 0.
 */
EAPI Eina_Bool
ecore_x_icccm_protocol_isset(Ecore_X_Window win,
                             Ecore_X_WM_Protocol protocol)
{
   Atom proto, *protos = NULL;
   int i, protos_count = 0;
   Eina_Bool ret = EINA_FALSE;

   /* check for invalid values */
   if (protocol >= ECORE_X_WM_PROTOCOL_NUM)
     return EINA_FALSE;

   LOGFN(__FILE__, __LINE__, __FUNCTION__);
   proto = _ecore_x_atoms_wm_protocols[protocol];

   if (!XGetWMProtocols(_ecore_x_disp, win, &protos, &protos_count))
     return EINA_FALSE;

   for (i = 0; i < protos_count; i++)
     if (protos[i] == proto)
       {
          ret = EINA_TRUE;
          break;
       }

   if (protos)
     XFree(protos);

   return ret;
}

/**
 * Set a window name & class.
 * @param win The window
 * @param n The name string
 * @param c The class string
 *
 * Set a window name * class
 */
EAPI void
ecore_x_icccm_name_class_set(Ecore_X_Window win,
                             const char *n,
                             const char *c)
{
   XClassHint *xch;

   xch = XAllocClassHint();
   if (!xch)
     return;

   LOGFN(__FILE__, __LINE__, __FUNCTION__);
   xch->res_name = (char *)n;
   xch->res_class = (char *)c;
   XSetClassHint(_ecore_x_disp, win, xch);
   XFree(xch);
}

/**
 * Get a window name & class.
 * @param win The window
 * @param n The name string
 * @param c The class string
 *
 * Get a window name * class
 */
EAPI void
ecore_x_icccm_name_class_get(Ecore_X_Window win,
                             char **n,
                             char **c)
{
   XClassHint xch;

   LOGFN(__FILE__, __LINE__, __FUNCTION__);
   if (n)
     *n = NULL;

   if (c)
     *c = NULL;

   xch.res_name = NULL;
   xch.res_class = NULL;
   if (XGetClassHint(_ecore_x_disp, win, &xch))
     {
        if (n)
          if (xch.res_name)
            *n = strdup(xch.res_name);

        if (c)
          if (xch.res_class)
            *c = strdup(xch.res_class);

        XFree(xch.res_name);
        XFree(xch.res_class);
     }
}

/**
 * Get a window client machine string.
 * @param win The window
 * @return The windows client machine string
 *
 * Return the client machine of a window. String must be free'd when done with.
 */
EAPI char *
ecore_x_icccm_client_machine_get(Ecore_X_Window win)
{
   char *name;

   LOGFN(__FILE__, __LINE__, __FUNCTION__);
   name = ecore_x_window_prop_string_get(win, ECORE_X_ATOM_WM_CLIENT_MACHINE);
   return name;
}

/**
 * Sets the WM_COMMAND property for @a win.
 *
 * @param win  The window.
 * @param argc Number of arguments.
 * @param argv Arguments.
 */
EAPI void
ecore_x_icccm_command_set(Ecore_X_Window win,
                          int argc,
                          char **argv)
{
   LOGFN(__FILE__, __LINE__, __FUNCTION__);
   XSetCommand(_ecore_x_disp, win, argv, argc);
}

/**
 * Get the WM_COMMAND property for @a win.
 *
 * Return the command of a window. String must be free'd when done with.
 *
 * @param win  The window.
 * @param argc Number of arguments.
 * @param argv Arguments.
 */
EAPI void
ecore_x_icccm_command_get(Ecore_X_Window win,
                          int *argc,
                          char ***argv)
{
   int i, c;
   char **v;

   if (argc)
     *argc = 0;

   if (argv)
     *argv = NULL;

   LOGFN(__FILE__, __LINE__, __FUNCTION__);
   if (!XGetCommand(_ecore_x_disp, win, &v, &c))
     return;

   if (c < 1)
     {
        if (v)
          XFreeStringList(v);

        return;
     }

   if (argc)
     *argc = c;

   if (argv)
     {
        (*argv) = malloc(c * sizeof(char *));
        if (!*argv)
          {
             XFreeStringList(v);
             if (argc)
               *argc = 0;

             return;
          }

        for (i = 0; i < c; i++)
          {
             if (v[i])
               (*argv)[i] = strdup(v[i]);
             else
               (*argv)[i] = strdup("");
          }
     }

   XFreeStringList(v);
}

/**
 * Set a window icon name.
 * @param win The window
 * @param t The icon name string
 *
 * Set a window icon name
 */
EAPI void
ecore_x_icccm_icon_name_set(Ecore_X_Window win,
                            const char *t)
{
   char *list[1];
   XTextProperty xprop;
   int ret;

   LOGFN(__FILE__, __LINE__, __FUNCTION__);
   xprop.value = NULL;
#ifdef X_HAVE_UTF8_STRING
   list[0] = strdup(t);
   ret = Xutf8TextListToTextProperty(_ecore_x_disp, list, 1,
                                     XUTF8StringStyle, &xprop);
#else /* ifdef X_HAVE_UTF8_STRING */
   list[0] = strdup(t);
   ret = XmbTextListToTextProperty(_ecore_x_disp, list, 1,
                                   XStdICCTextStyle, &xprop);
#endif /* ifdef X_HAVE_UTF8_STRING */
   if (ret >= Success)
     {
        XSetWMIconName(_ecore_x_disp, win, &xprop);
        if (xprop.value)
          XFree(xprop.value);
     }
   else if (XStringListToTextProperty(list, 1, &xprop) >= Success)
     {
        XSetWMIconName(_ecore_x_disp, win, &xprop);
        if (xprop.value)
          XFree(xprop.value);
     }

   free(list[0]);
}

/**
 * Get a window icon name.
 * @param win The window
 * @return The windows icon name string
 *
 * Return the icon name of a window. String must be free'd when done with.
 */
EAPI char *
ecore_x_icccm_icon_name_get(Ecore_X_Window win)
{
   XTextProperty xprop;

   LOGFN(__FILE__, __LINE__, __FUNCTION__);
   xprop.value = NULL;
   if (XGetWMIconName(_ecore_x_disp, win, &xprop) >= Success)
     {
        if (xprop.value)
          {
             char **list = NULL;
             char *t = NULL;
             int num = 0;
             int ret;

             if (xprop.encoding == ECORE_X_ATOM_UTF8_STRING)
               t = strdup((char *)xprop.value);
             else
               {
                  /* convert to utf8 */
#ifdef X_HAVE_UTF8_STRING
                  ret = Xutf8TextPropertyToTextList(_ecore_x_disp, &xprop,
                                                    &list, &num);
#else /* ifdef X_HAVE_UTF8_STRING */
                  ret = XmbTextPropertyToTextList(_ecore_x_disp, &xprop,
                                                  &list, &num);
#endif /* ifdef X_HAVE_UTF8_STRING */

                  if ((ret == XLocaleNotSupported) ||
                      (ret == XNoMemory) || (ret == XConverterNotFound))
                    t = strdup((char *)xprop.value);
                  else if (ret >= Success)
                    {
                       if ((num >= 1) && (list))
                         t = strdup(list[0]);

                       if (list)
                         XFreeStringList(list);
                    }
               }

             if (xprop.value)
               XFree(xprop.value);

             return t;
          }
     }

   return NULL;
}

/**
 * Add a subwindow to the list of windows that need a different colormap installed.
 * @param win The toplevel window
 * @param subwin The subwindow to be added to the colormap windows list
 */
EAPI void
ecore_x_icccm_colormap_window_set(Ecore_X_Window win,
                                  Ecore_X_Window subwin)
{
   int num = 0, i;
   unsigned char *old_data = NULL;
   unsigned char *data = NULL;
   Window *oldset = NULL;
   Window *newset = NULL;

   LOGFN(__FILE__, __LINE__, __FUNCTION__);
   if (!ecore_x_window_prop_property_get(win,
                                         ECORE_X_ATOM_WM_COLORMAP_WINDOWS,
                                         XA_WINDOW, 32, &old_data, &num))
     {
        newset = calloc(1, sizeof(Window));
        if (!newset)
          return;

        newset[0] = subwin;
        num = 1;
        data = (unsigned char *)newset;
     }
   else
     {
        newset = calloc(num + 1, sizeof(Window));
        oldset = (Window *)old_data;
        if (!newset)
          return;

        for (i = 0; i < num; ++i)
          {
             if (oldset[i] == subwin)
               {
                  if (old_data)
                    XFree(old_data);

                  old_data = NULL;
                  free(newset);
                  return;
               }

             newset[i] = oldset[i];
          }

        newset[num++] = subwin;
        if (old_data)
          XFree(old_data);

        data = (unsigned char *)newset;
     }

   ecore_x_window_prop_property_set(win,
                                    ECORE_X_ATOM_WM_COLORMAP_WINDOWS,
                                    XA_WINDOW, 32, data, num);
   free(newset);
}

/**
 * Remove a window from the list of colormap windows.
 * @param win The toplevel window
 * @param subwin The window to be removed from the colormap window list.
 */
EAPI void
ecore_x_icccm_colormap_window_unset(Ecore_X_Window win,
                                    Ecore_X_Window subwin)
{
   int num = 0, i, j, k = 0;
   unsigned char *old_data = NULL;
   unsigned char *data = NULL;
   Window *oldset = NULL;
   Window *newset = NULL;

   LOGFN(__FILE__, __LINE__, __FUNCTION__);
   if (!ecore_x_window_prop_property_get(win,
                                         ECORE_X_ATOM_WM_COLORMAP_WINDOWS,
                                         XA_WINDOW, 32, &old_data, &num))
     return;

   oldset = (Window *)old_data;
   for (i = 0; i < num; i++)
     {
        if (oldset[i] == subwin)
          {
             if (num == 1)
               {
                  XDeleteProperty(_ecore_x_disp,
                                  win, ECORE_X_ATOM_WM_COLORMAP_WINDOWS);
                  if (old_data)
                    XFree(old_data);

                  old_data = NULL;
                  return;
               }
             else
               {
                  newset = calloc(num - 1, sizeof(Window));
                  data = (unsigned char *)newset;
                  for (j = 0; j < num; ++j)
                    if (oldset[j] != subwin)
                      newset[k++] = oldset[j];

                  ecore_x_window_prop_property_set(
                    win,
                    ECORE_X_ATOM_WM_COLORMAP_WINDOWS,
                    XA_WINDOW,
                    32,
                    data,
                    k);
                  if (old_data)
                    XFree(old_data);

                  old_data = NULL;
                  free(newset);
                  return;
               }
          }
     }

   if (old_data)
     XFree(old_data);
}

/**
 * Specify that a window is transient for another top-level window and should be handled accordingly.
 * @param win the transient window
 * @param forwin the toplevel window
 */
EAPI void
ecore_x_icccm_transient_for_set(Ecore_X_Window win,
                                Ecore_X_Window forwin)
{
   LOGFN(__FILE__, __LINE__, __FUNCTION__);
   XSetTransientForHint(_ecore_x_disp, win, forwin);
}

/**
 * Remove the transient_for setting from a window.
 * @param win The window
 */
EAPI void
ecore_x_icccm_transient_for_unset(Ecore_X_Window win)
{
   LOGFN(__FILE__, __LINE__, __FUNCTION__);
   XDeleteProperty(_ecore_x_disp, win, ECORE_X_ATOM_WM_TRANSIENT_FOR);
}

/**
 * Get the window this window is transient for, if any.
 * @param win The window to check
 * @return The window ID of the top-level window, or 0 if the property does not exist.
 */
EAPI Ecore_X_Window
ecore_x_icccm_transient_for_get(Ecore_X_Window win)
{
   Window forwin;

   LOGFN(__FILE__, __LINE__, __FUNCTION__);
   if (XGetTransientForHint(_ecore_x_disp, win, &forwin))
     return (Ecore_X_Window)forwin;
   else
     return 0;
}

/**
 * Set the window role hint.
 * @param win The window
 * @param role The role string
 */
EAPI void
ecore_x_icccm_window_role_set(Ecore_X_Window win,
                              const char *role)
{
   LOGFN(__FILE__, __LINE__, __FUNCTION__);
   ecore_x_window_prop_string_set(win, ECORE_X_ATOM_WM_WINDOW_ROLE,
                                  (char *)role);
}

/**
 * Get the window role.
 * @param win The window
 * @return The window's role string.
 */
EAPI char *
ecore_x_icccm_window_role_get(Ecore_X_Window win)
{
   LOGFN(__FILE__, __LINE__, __FUNCTION__);
   return ecore_x_window_prop_string_get(win, ECORE_X_ATOM_WM_WINDOW_ROLE);
}

/**
 * Set the window's client leader.
 * @param win The window
 * @param l The client leader window
 *
 * All non-transient top-level windows created by an app other than
 * the main window must have this property set to the app's main window.
 */
EAPI void
ecore_x_icccm_client_leader_set(Ecore_X_Window win,
                                Ecore_X_Window l)
{
   LOGFN(__FILE__, __LINE__, __FUNCTION__);
   ecore_x_window_prop_window_set(win, ECORE_X_ATOM_WM_CLIENT_LEADER,
                                  &l, 1);
}

/**
 * Get the window's client leader.
 * @param win The window
 * @return The window's client leader window, or 0 if unset */
EAPI Ecore_X_Window
ecore_x_icccm_client_leader_get(Ecore_X_Window win)
{
   Ecore_X_Window l;

   LOGFN(__FILE__, __LINE__, __FUNCTION__);
   if (ecore_x_window_prop_window_get(win, ECORE_X_ATOM_WM_CLIENT_LEADER,
                                      &l, 1) > 0)
     return l;

   return 0;
}

EAPI void
ecore_x_icccm_iconic_request_send(Ecore_X_Window win,
                                  Ecore_X_Window root)
{
   XEvent xev;

   if (!win)
     return;

   LOGFN(__FILE__, __LINE__, __FUNCTION__);
   if (!root)
     root = DefaultRootWindow(_ecore_x_disp);

   xev.xclient.type = ClientMessage;
   xev.xclient.serial = 0;
   xev.xclient.send_event = True;
   xev.xclient.display = _ecore_x_disp;
   xev.xclient.window = win;
   xev.xclient.format = 32;
   xev.xclient.message_type = ECORE_X_ATOM_WM_CHANGE_STATE;
   xev.xclient.data.l[0] = IconicState;

   XSendEvent(_ecore_x_disp, root, False,
              SubstructureNotifyMask | SubstructureRedirectMask, &xev);
}

/* FIXME: there are older E hints, gnome hints and mwm hints and new netwm */
/*        hints. each should go in their own file/section so we know which */
/*        is which. also older kde hints too. we should try support as much */
/*        as makese sense to support */