mutter/src/compositor.c

/* 
 * Copyright (C) 2003, 2004, 2005, 2006 Red Hat, Inc.
 * Copyright (C) 2003 Keith Packard
 * 
 * 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., 59 Temple Place - Suite 330, Boston, MA
 * 02111-1307, USA.
 */

#include <config.h>
#include "compositor.h"
#include "screen.h"
#include "errors.h"
#include "window.h"
#include "frame.h"
#include "workspace.h"

#include <math.h>

#ifdef HAVE_COMPOSITE_EXTENSIONS
#include <cm/node.h>
#include <cm/drawable-node.h>

#include <GL/gl.h>
#include <GL/glu.h>
#include <GL/glx.h>

#include <cm/ws.h>
#include <cm/wsint.h>

#include <X11/extensions/shape.h>
#include <X11/extensions/Xcomposite.h>
#include <X11/extensions/Xdamage.h>
#include <X11/extensions/Xfixes.h>
#include <X11/extensions/Xrender.h>
#endif /* HAVE_COMPOSITE_EXTENSIONS */

#define FRAME_INTERVAL_MILLISECONDS ((int)(1000.0/40.0))

#ifdef HAVE_COMPOSITE_EXTENSIONS
/* Screen specific information */
typedef struct
{
  /* top of stack is first in list */
  GList *compositor_nodes;
  WsWindow *glw;
  int idle_id;
} ScreenInfo;

struct MetaCompositor
{
  MetaDisplay *meta_display;
  
  WsDisplay *display;
  
  GHashTable *window_hash;
  
  guint repair_idle;
  
  guint enabled : 1;
  guint have_composite : 1;
  guint have_damage : 1;
  guint have_fixes : 1;
  guint have_name_window_pixmap : 1;
  guint debug_updates : 1;
  
  GList *ignored_damage;
};
#endif /* HAVE_COMPOSITE_EXTENSIONS */

#ifdef HAVE_COMPOSITE_EXTENSIONS
static void
free_window_hash_value (void *v)
{
  CmDrawableNode *drawable_node = v;
  
  g_object_unref (G_OBJECT (drawable_node));
}
#endif /* HAVE_COMPOSITE_EXTENSIONS */

MetaCompositor*
meta_compositor_new (MetaDisplay *display)
{
#ifdef HAVE_COMPOSITE_EXTENSIONS
  MetaCompositor *compositor;
  
  compositor = g_new0 (MetaCompositor, 1);
  
  compositor->display = ws_display_new (NULL);

  ws_display_set_synchronize (compositor->display,
			      getenv ("METACITY_SYNC") != NULL);
  
  ws_display_init_test (compositor->display);
  ws_display_set_ignore_grabs (compositor->display, TRUE);
  
  compositor->meta_display = display;
  
  compositor->window_hash = g_hash_table_new_full (
      meta_unsigned_long_hash,
      meta_unsigned_long_equal,
      NULL,
      free_window_hash_value);
  
  compositor->enabled = TRUE;
  
  return compositor;
#else /* HAVE_COMPOSITE_EXTENSIONS */
  return NULL;
#endif /* HAVE_COMPOSITE_EXTENSIONS */
}

void
meta_compositor_set_debug_updates (MetaCompositor *compositor,
				   gboolean	   debug_updates)
{
#ifdef HAVE_COMPOSITE_EXTENSIONS
  compositor->debug_updates = !!debug_updates;
#endif /* HAVE_COMPOSITE_EXTENSIONS */
}

#ifdef HAVE_COMPOSITE_EXTENSIONS
static void
remove_repair_idle (MetaCompositor *compositor)
{
  if (compositor->repair_idle)
    {
      meta_topic (META_DEBUG_COMPOSITOR, "Damage idle removed\n");
      
      g_source_remove (compositor->repair_idle);
      compositor->repair_idle = 0;
    }
}
#endif /* HAVE_COMPOSITE_EXTENSIONS */

void
meta_compositor_unref (MetaCompositor *compositor)
{
#ifdef HAVE_COMPOSITE_EXTENSIONS
  /* There isn't really a refcount at the moment since
   * there's no ref()
   */
  remove_repair_idle (compositor);
  
  if (compositor->window_hash)
    g_hash_table_destroy (compositor->window_hash);
  
  g_free (compositor);
#endif /* HAVE_COMPOSITE_EXTENSIONS */
}

#ifdef HAVE_COMPOSITE_EXTENSIONS
static void
draw_windows (MetaScreen *screen,
	      GList      *list)
{
  CmNode *node;
  
  if (!list)
    return;
  
  node = list->data;
  
  draw_windows (screen, list->next);

#if 0
  g_print ("rendering: %p\n", node);
#endif
  
  cm_node_render (node);
}

static MetaScreen *
node_get_screen (Display *dpy,
		 CmDrawableNode *node)
{
  /* FIXME: we should probably have a reverse mapping
   * from nodes to screens
   */
  
  Screen *screen = XDefaultScreenOfDisplay (dpy);
  return meta_screen_for_x_screen (screen);
}

static void
handle_restacking (MetaCompositor *compositor,
		   CmDrawableNode *node,
		   CmDrawableNode *above)
{
  GList *window_link, *above_link;
  MetaScreen *screen;
  ScreenInfo *scr_info;
  
  screen = node_get_screen (compositor->meta_display->xdisplay, node);
  scr_info = screen->compositor_data;
  
  window_link = g_list_find (scr_info->compositor_nodes, node);
  above_link  = g_list_find (scr_info->compositor_nodes, above);
  
  if (!window_link || !above_link)
    return;
  
  if (window_link == above_link)
    {
      /* This can happen if the topmost window is raised above
       * the GL window
       */
      return;
    }

  g_print ("restacking\n");
  
  if (window_link->next != above_link)
    {
      ScreenInfo *scr_info = screen->compositor_data;
      
      scr_info->compositor_nodes =
	g_list_delete_link (scr_info->compositor_nodes, window_link);
      scr_info->compositor_nodes =
	g_list_insert_before (scr_info->compositor_nodes, above_link, node);
    }
}

static void
process_configure_notify (MetaCompositor  *compositor,
                          XConfigureEvent *event)
{
  WsWindow *above_window;
  CmDrawableNode *node = g_hash_table_lookup (compositor->window_hash,
					      &event->window);
  CmDrawableNode *above_node;
  MetaScreen *screen;
  ScreenInfo *scr_info;
  
#if 0
  g_print ("processing configure\n");
#endif
  
  if (!node)
    return;

#if 0
  g_print ("we do now have a node\n");
#endif
  
  screen = node_get_screen (compositor->meta_display->xdisplay, node);
  scr_info = screen->compositor_data;
  
  above_window = ws_window_lookup (WS_RESOURCE (node->drawable)->display,
				   event->above);
  
  if (above_window == scr_info->glw)
    {
      above_node = scr_info->compositor_nodes->data;
    }
  else
    {
      above_node = g_hash_table_lookup (compositor->window_hash,
					&event->above);
    }
  
  handle_restacking (compositor, node, above_node);
}
#endif /* HAVE_COMPOSITE_EXTENSIONS */


#ifdef HAVE_COMPOSITE_EXTENSIONS
static void
process_expose (MetaCompositor     *compositor,
                XExposeEvent       *event)
{
  /* FIXME: queue repaint */
}

#endif /* HAVE_COMPOSITE_EXTENSIONS */

#ifdef HAVE_COMPOSITE_EXTENSIONS
static void queue_repaint (CmDrawableNode *node, gpointer data);

typedef struct
{
    CmDrawableNode *node;
    GTimer	   *timer;
} FadeInfo;

#define FADE_TIME 0.3

static gboolean
fade_in (gpointer data)
{
    FadeInfo *info = data;
    gdouble elapsed = g_timer_elapsed (info->timer, NULL);
    gdouble alpha;

    if (elapsed > FADE_TIME)
	alpha = 1.0;
    else
	alpha = elapsed / FADE_TIME;

    cm_drawable_node_set_alpha (info->node, alpha);

    if (elapsed >= FADE_TIME)
    {
	g_object_unref (info->node);
	return FALSE;
    }
    else
    {
	return TRUE;
    }
}

static gboolean
fade_out (gpointer data)
{
    FadeInfo *info = data;
    gdouble elapsed = g_timer_elapsed (info->timer, NULL);
    gdouble alpha;

    if (elapsed > FADE_TIME)
	alpha = 0.0;
    else
	alpha = 1 - (elapsed / FADE_TIME);

    cm_drawable_node_set_alpha (info->node, alpha);

    g_print ("fade out: %f\n", alpha);
    
    if (elapsed >= FADE_TIME)
    {
	cm_drawable_node_set_viewable (info->node, FALSE);

	g_object_unref (info->node);
	return FALSE;
    }
    else
    {
	return TRUE;
    }
}
#endif

#ifdef HAVE_COMPOSITE_EXTENSIONS
static void
process_map (MetaCompositor     *compositor,
             XMapEvent          *event)
{
  CmDrawableNode *node;
  MetaScreen *screen;

  /* FIXME: do we sometimes get mapnotifies for windows that are
   * not (direct) children of the root?
   */
  
  /* See if window was mapped as child of root */
  screen = meta_display_screen_for_root (compositor->meta_display,
					 event->event);

  if (screen == NULL)
    {
      meta_topic (META_DEBUG_COMPOSITOR,
		  "MapNotify received on non-root 0x%lx for 0x%lx\n",
		  event->event, event->window);
      return; /* MapNotify wasn't for a child of the root */
    }
  
  g_print ("processing map for %lx\n", event->window);
  
  node = g_hash_table_lookup (compositor->window_hash,
			      &event->window);
  if (node == NULL)
    {
      XWindowAttributes attrs;
      
      meta_error_trap_push_with_return (compositor->meta_display);
      
      XGetWindowAttributes (compositor->meta_display->xdisplay,
			    event->window, &attrs);
      
      if (meta_error_trap_pop_with_return (compositor->meta_display, TRUE) != Success)
        {
	  meta_topic (META_DEBUG_COMPOSITOR, "Failed to get attributes for window 0x%lx\n",
		      event->window);
        }
      else
	{
	  meta_compositor_add_window (compositor,
				      event->window, &attrs);
        }
    }
  else
    {
      cm_drawable_node_update_pixmap (node);

      cm_drawable_node_set_alpha (node, 0.0);
      
      FadeInfo *info = g_new (FadeInfo, 1);
      
      info->node = g_object_ref (node);
      info->timer = g_timer_new ();
      
      g_idle_add (fade_in, info);
      
      cm_drawable_node_set_viewable (node, TRUE);
    }

  queue_repaint (node, screen);
}
#endif /* HAVE_COMPOSITE_EXTENSIONS */

#ifdef HAVE_COMPOSITE_EXTENSIONS
static void
process_unmap (MetaCompositor     *compositor,
               XUnmapEvent        *event)
{
  CmDrawableNode *node;
  MetaScreen *screen;

  /* See if window was unmapped as child of root */
  screen = meta_display_screen_for_root (compositor->meta_display,
					 event->event);
  
  if (screen == NULL)
    {
      meta_topic (META_DEBUG_COMPOSITOR,
		  "UnmapNotify received on non-root 0x%lx for 0x%lx\n",
		  event->event, event->window);
      return; /* UnmapNotify wasn't for a child of the root */
    }
  
  g_print ("processing unmap on %lx\n", event->window);
  
  node = g_hash_table_lookup (compositor->window_hash,
			      &event->window);
  if (node != NULL)
    {
      FadeInfo *info = g_new (FadeInfo, 1);
      
      info->node = g_object_ref (node);
      info->timer = g_timer_new ();
      
      g_idle_add (fade_out, info);
    }
  
  queue_repaint (node, screen);
}
#endif /* HAVE_COMPOSITE_EXTENSIONS */

#ifdef HAVE_COMPOSITE_EXTENSIONS
static void
process_create (MetaCompositor     *compositor,
                XCreateWindowEvent *event)
{
  MetaScreen *screen;
  XWindowAttributes attrs;
  
  screen = meta_display_screen_for_root (compositor->meta_display,
					 event->parent);
  
  if (screen == NULL)
    {
      meta_topic (META_DEBUG_COMPOSITOR,
		  "CreateNotify received on non-root 0x%lx for 0x%lx\n",
		  event->parent, event->window);
      return;
    }
  
  meta_error_trap_push_with_return (compositor->meta_display);
  
  XGetWindowAttributes (compositor->meta_display->xdisplay,
			event->window, &attrs);
  
  if (meta_error_trap_pop_with_return (compositor->meta_display, TRUE) != Success)
    {
      meta_topic (META_DEBUG_COMPOSITOR, "Failed to get attributes for window 0x%lx\n",
		  event->window);
    }
  else
    {
	g_print (//META_DEBUG_COMPOSITOR,
		  "Create window 0x%lx, adding\n", event->window);
      
      meta_compositor_add_window (compositor,
				  event->window, &attrs);
    }
}
#endif /* HAVE_COMPOSITE_EXTENSIONS */

#ifdef HAVE_COMPOSITE_EXTENSIONS
static void
process_destroy (MetaCompositor      *compositor,
                 XDestroyWindowEvent *event)
{
  MetaScreen *screen;
  
  screen = meta_display_screen_for_root (compositor->meta_display,
					 event->event);
  
  if (screen == NULL)
    {
      meta_topic (META_DEBUG_COMPOSITOR,
		  "DestroyNotify received on non-root 0x%lx for 0x%lx\n",
		  event->event, event->window);
      return;
    }
  
  meta_topic (META_DEBUG_COMPOSITOR,
	      "Destroy window 0x%lx\n", event->window);
  meta_compositor_remove_window (compositor, event->window);
}
#endif /* HAVE_COMPOSITE_EXTENSIONS */


#ifdef HAVE_COMPOSITE_EXTENSIONS
static void
process_reparent (MetaCompositor      *compositor,
                  XReparentEvent      *event)
{
  /* Reparent from one screen to another doesn't happen now, but
   * it's been suggested as a future extension
   */
  MetaScreen *event_screen;
  MetaScreen *parent_screen;
  CmDrawableNode *node;
  XWindowAttributes attrs;
  
  event_screen = meta_display_screen_for_root (compositor->meta_display,
					       event->event);

  if (event_screen == NULL)
    {
      meta_topic (META_DEBUG_COMPOSITOR,
		  "ReparentNotify received on non-root 0x%lx for 0x%lx\n",
		  event->event, event->window);
      return;
    }
  
  g_print (//META_DEBUG_COMPOSITOR,
	      "Reparent window 0x%lx new parent 0x%lx received on 0x%lx\n",
	      event->window, event->parent, event->event);
  
  parent_screen = meta_display_screen_for_root (compositor->meta_display,
						event->parent);
  
  if (parent_screen == NULL)
    {
      meta_topic (META_DEBUG_COMPOSITOR,
		  "ReparentNotify 0x%lx to a non-screen or unmanaged screen 0x%lx\n",
		  event->window, event->parent);
      meta_compositor_remove_window (compositor, event->window);
      return;
    }
  
  node = g_hash_table_lookup (compositor->window_hash,
			      &event->window);
  
  meta_error_trap_push_with_return (compositor->meta_display);
  
  XGetWindowAttributes (compositor->meta_display->xdisplay,
			event->window, &attrs);
  
  if (meta_error_trap_pop_with_return (compositor->meta_display, TRUE) != Success)
    {
      meta_topic (META_DEBUG_COMPOSITOR, "Failed to get attributes for window 0x%lx\n",
		  event->window);
    }
  else
    {
      meta_topic (META_DEBUG_COMPOSITOR,
		  "Reparent window 0x%lx into screen 0x%lx, adding\n",
		  event->window, event->parent);
      meta_compositor_add_window (compositor,
				  event->window, &attrs);
    }
}
#endif /* HAVE_COMPOSITE_EXTENSIONS */

void
meta_compositor_process_event (MetaCompositor *compositor,
                               XEvent         *event,
                               MetaWindow     *window)
{
#ifdef HAVE_COMPOSITE_EXTENSIONS
  if (!compositor->enabled)
    return; /* no extension */
  
  /* FIXME support CirculateNotify */
  
  if (event->type == ConfigureNotify)
    {
      process_configure_notify (compositor,
				(XConfigureEvent*) event);
    }
  else if (event->type == Expose)
    {
      process_expose (compositor,
		      (XExposeEvent*) event);
    }
  else if (event->type == UnmapNotify)
    {
      process_unmap (compositor,
		     (XUnmapEvent*) event);
    }
  else if (event->type == MapNotify)
    {
      process_map (compositor,
		   (XMapEvent*) event);
    }
  else if (event->type == ReparentNotify)
    {
      process_reparent (compositor,
			(XReparentEvent*) event);
    }
  else if (event->type == CreateNotify)
    {
      process_create (compositor,
		      (XCreateWindowEvent*) event);
    }
  else if (event->type == DestroyNotify)
    {
      process_destroy (compositor,
		       (XDestroyWindowEvent*) event);
    }
  
#endif /* HAVE_COMPOSITE_EXTENSIONS */
}

#ifdef HAVE_COMPOSITE_EXTENSIONS
static void
wavy (double time,
      double in_x, double in_y,
      double *out_x, double *out_y,
      gpointer data)
{
  static int m;
  time = time * 5;
  double dx = 0.0025 * sin (time + 35 * in_y);
  double dy = 0.0025 * cos (time + 35 * in_x);
  
  *out_x = in_x + dx;
  *out_y = in_y + dy;
  
  m++;
}

static void
update_frame_counter (void)
{
#define BUFSIZE 128
    static GTimer *timer;
    static double buffer [BUFSIZE];
    static int next = 0;

    if (!timer)
	timer = g_timer_new ();

    buffer[next++] = g_timer_elapsed (timer, NULL);

    if (next == BUFSIZE)
    {
	int i;
	double total;
	
	next = 0;

	total = 0.0;
	for (i = 1; i < BUFSIZE; ++i)
	    total += buffer[i] - buffer[i - 1];

	g_print ("frames per second: %f\n", 1 / (total / (BUFSIZE - 1)));
    }
}

static gboolean
update (gpointer data)
{
  MetaScreen *screen = data;
  ScreenInfo *scr_info = screen->compositor_data;
  WsWindow *gl_window = scr_info->glw;

  glViewport (0, 0, screen->rect.width, screen->rect.height);
  
#if 0
  glColor4f (1.0, 1.0, 1.0, 1.0);
  glBegin (GL_QUADS);
  glVertex2f (0.0, 0.0);
  glVertex2f (1600.0, 0.0);
  glVertex2f (1600.0, 1200.0);
  glVertex2f (0.0, 1200.0);
  glEnd ();
#endif
  
#if 0
#endif
#if 0
  glClear (GL_DEPTH_BUFFER_BIT);
#endif

#if 0
  glColor4f (1.0, 0.0, 0.0, 1.0);
  
  glDisable (GL_TEXTURE_2D);
  glDisable (GL_DEPTH_TEST);
  
  glBegin (GL_QUADS);
  
  glVertex2f (0.2, 0.2);
  glVertex2f (0.2, 0.4);
  glVertex2f (0.4, 0.4);
  glVertex2f (0.4, 0.2);
  
  glEnd ();
#endif
  
#if 0
  glClearColor (1.0, 1.0, 1.0, 1.0);
  glClear (GL_COLOR_BUFFER_BIT);
#endif
  
#if 0
  glEnable (GL_TEXTURE_2D);
#endif
  glDisable (GL_TEXTURE_2D);
  glDisable (GL_DEPTH_TEST);
  ws_window_raise (gl_window);
  
  draw_windows (screen, scr_info->compositor_nodes);
  
  /* FIXME: we should probably grab the server around the raise/swap
   */

#if 0
  ws_display_grab (ws_drawable_get_display ((WsDrawable *)gl_window));
#endif

  g_print ("swap buffers\n");
  ws_window_gl_swap_buffers (gl_window);
  g_print ("finish\n");
  glFinish();
  g_print ("after finish\n");

  update_frame_counter ();

#if 0
  ws_display_ungrab (ws_drawable_get_display ((WsDrawable *)gl_window));
#endif
  
  scr_info->idle_id = 0;

  return FALSE;
}

static void
queue_repaint (CmDrawableNode *node, gpointer data)
{
    MetaScreen *screen = data;
    ScreenInfo *scr_info = screen->compositor_data;

#if 0
    g_print ("metacity queueing repaint for %p\n", node);
#endif
    
    if (!scr_info->idle_id)
    {
	scr_info->idle_id = g_idle_add (update, screen);
#if 0
	g_print ("done\n");
#endif
    }
    else
    {
#if 0
	g_print ("one was queued already\n");
#endif
    }
}
#endif /* HAVE_COMPOSITE_EXTENSIONS */

#ifdef HAVE_COMPOSITE_EXTENSIONS
static void
dump_stacking_order (GList *nodes)
{
    GList *list;

    for (list = nodes; list != NULL; list = list->next)
    {
	CmDrawableNode *node = list->data;
	
	g_print ("%lx, ", WS_RESOURCE_XID (node->drawable));
    }
    g_print ("\n");
}
#endif

/* This is called when metacity does its XQueryTree() on startup
 * and when a new window is mapped.
 */
void
meta_compositor_add_window (MetaCompositor    *compositor,
                            Window             xwindow,
                            XWindowAttributes *attrs)
{
#ifdef HAVE_COMPOSITE_EXTENSIONS
  CmDrawableNode *node;
  MetaScreen *screen;
  WsDrawable *drawable;
  ScreenInfo *scr_info;
  
  if (!compositor->enabled)
    return; /* no extension */
  
  screen = meta_screen_for_x_screen (attrs->screen);
  g_assert (screen != NULL);
  
  node = g_hash_table_lookup (compositor->window_hash,
			      &xwindow);
  
  g_print ("adding %lx\n", xwindow);
  
  if (node != NULL)
    {
	g_print ("window %lx already added\n", xwindow);
      meta_topic (META_DEBUG_COMPOSITOR,
		  "Window 0x%lx already added\n", xwindow);
      return;
    }

  ws_display_begin_error_trap (compositor->display);
  
  drawable = (WsDrawable *)ws_window_lookup (compositor->display, xwindow);

  scr_info = screen->compositor_data;

  ws_display_end_error_trap (compositor->display);

  if (!drawable)
      return;
  
  g_assert (scr_info);

  ws_display_begin_error_trap (compositor->display);
  
  if (ws_window_query_input_only ((WsWindow *)drawable) ||
      drawable == (WsDrawable *)scr_info->glw)
    {
	ws_display_end_error_trap (compositor->display);
      return;
    }

  ws_display_end_error_trap (compositor->display);

  node = cm_drawable_node_new (drawable);
  
  cm_drawable_node_set_damage_func (node, queue_repaint, screen);
#if 0
  drawable_node_set_deformation_func (node, wavy, NULL);
#endif
  
  /* FIXME: we should probably just store xid's directly */
  g_hash_table_insert (compositor->window_hash,
		       &(WS_RESOURCE (node->drawable)->xid), node);
  
  /* assume cwindow is at the top of the stack as it was either just
   * created or just reparented to the root window
   */
  scr_info->compositor_nodes = g_list_prepend (scr_info->compositor_nodes,
					       node);

  dump_stacking_order (scr_info->compositor_nodes);
  
#endif /* HAVE_COMPOSITE_EXTENSIONS */
}
void
meta_compositor_remove_window (MetaCompositor    *compositor,
                               Window             xwindow)
{
#ifdef HAVE_COMPOSITE_EXTENSIONS
  CmDrawableNode *node;
  MetaScreen *screen;
  ScreenInfo *scr_info;
  
  if (!compositor->enabled)
    return; /* no extension */
  
  node = g_hash_table_lookup (compositor->window_hash,
			      &xwindow);
  
  if (node == NULL)
    {
      meta_topic (META_DEBUG_COMPOSITOR,
		  "Window 0x%lx already removed\n", xwindow);
      return;
    }
  
  screen = node_get_screen (compositor->meta_display->xdisplay, node);
  scr_info = screen->compositor_data;
  
  scr_info->compositor_nodes = g_list_remove (scr_info->compositor_nodes,
					      node);
  
  /* Frees node as side effect */
  g_hash_table_remove (compositor->window_hash,
		       &xwindow);
  
#endif /* HAVE_COMPOSITE_EXTENSIONS */
}

void
meta_compositor_manage_screen (MetaCompositor *compositor,
                               MetaScreen     *screen)
{
#ifdef HAVE_COMPOSITE_EXTENSIONS
  ScreenInfo *scr_info = g_new0 (ScreenInfo, 1);
  
  WsScreen *ws_screen =
      ws_display_get_screen_from_number (compositor->display, screen->number);
  WsWindow *root = ws_screen_get_root_window (ws_screen);
  WsRegion *region;
  Window current_cm_sn_owner;
  WsWindow *new_cm_sn_owner;
  Display *xdisplay;
  Atom cm_sn_atom;
  char buf[128];
  Atom atom;

  scr_info->glw = ws_window_new_gl (root);
  scr_info->compositor_nodes = NULL;
  scr_info->idle_id = 0;

  g_print ("setting compositor_data for screen %p to %p\n", screen, scr_info);
  screen->compositor_data = scr_info;
  
  ws_display_init_composite (compositor->display);
  ws_display_init_damage (compositor->display);
  ws_display_init_fixes (compositor->display);
  
  ws_window_redirect_subwindows (root);
  ws_window_set_override_redirect (scr_info->glw, TRUE);
  ws_window_unredirect (scr_info->glw);
  
  region = ws_region_new (compositor->display);
  ws_window_set_input_shape (scr_info->glw, region);
  g_object_unref (G_OBJECT (region));

  xdisplay = WS_RESOURCE_XDISPLAY (ws_screen);
  snprintf(buf, sizeof(buf), "CM_S%d", screen->number);
  cm_sn_atom = XInternAtom (xdisplay, buf, False);
  current_cm_sn_owner = XGetSelectionOwner (xdisplay, cm_sn_atom);

  if (current_cm_sn_owner != None)
  {
      meta_warning (_("Screen %d on display \"%s\" already has a compositing manager\n"),
		    screen->number, ",madgh");
  }
  
  new_cm_sn_owner = ws_screen_get_root_window (ws_screen);

  XSetSelectionOwner (xdisplay, cm_sn_atom, WS_RESOURCE_XID (new_cm_sn_owner),
                      CurrentTime);
  
  ws_window_map (scr_info->glw);
  
  ws_display_sync (compositor->display);

#if 0
  children = ws_window_list_children (root);
#endif
  
#endif
}

void
meta_compositor_unmanage_screen (MetaCompositor *compositor,
                                 MetaScreen     *screen)
{
#ifdef HAVE_COMPOSITE_EXTENSIONS  
  ScreenInfo *scr_info = screen->compositor_data;
  
  if (!compositor->enabled)
    return; /* no extension */
  
  while (scr_info->compositor_nodes != NULL)
    {
      CmDrawableNode *node = scr_info->compositor_nodes->data;
      
      meta_compositor_remove_window (compositor,
				     WS_RESOURCE (node->drawable)->xid);
    }
  /* FIXME: free scr_info */
  
#endif /* HAVE_COMPOSITE_EXTENSIONS */
}

#ifdef HAVE_COMPOSITE_EXTENSIONS  
static CmDrawableNode *
window_to_node (MetaCompositor *compositor,
		MetaWindow *window)
{
  Window xwindow;
  CmDrawableNode *node;
  
  if (window->frame)
    xwindow = window->frame->xwindow;
  else
    xwindow = window->xwindow;
  
  node = g_hash_table_lookup (compositor->window_hash,
			      &xwindow);
  
  return node;
}

typedef struct
{
  double x;
  double y;
  double width;
  double height;
} DoubleRect;

#if 0
static gdouble
interpolate (gdouble t, gdouble begin, gdouble end, double power)
{
  return (begin + (end - begin) * pow (t, power));
}
#endif

#if 0
static gboolean
stop_minimize (gpointer data)
{
  MiniInfo *info = data;
  
  g_source_remove (info->repaint_id);
  
  cm_drawable_node_set_deformation_func (info->node, NULL, NULL);

  if (info->finished_func)
    info->finished_func (info->finished_data);

  g_free (info);
  
  return FALSE;
}
#endif

#if 0
static void
minimize_deformation (gdouble time,
		      double in_x,
		      double in_y,
		      double *out_x,
		      double *out_y,
		      gpointer data)
{
#define MINIMIZE_TIME 0.5
  MiniInfo *info = data;
  gdouble elapsed;
  gdouble pos;
  
  if (info->start_time == -1)
    info->start_time = time;
  
  elapsed = time - info->start_time;
  pos = elapsed / MINIMIZE_TIME;
  
  *out_x = interpolate (pos, in_x, info->target.x + info->target.width * ((in_x - info->start.x)  / info->start.width), 10 * in_y);
  *out_y = interpolate (pos, in_y, info->target.y + info->target.height * ((in_y - info->start.y)  / info->start.height), 1.0);

  if (elapsed > MINIMIZE_TIME)
    {
      g_assert (info->node);
      if (!info->idle_id)
	info->idle_id = g_idle_add (stop_minimize, info);
    }
}
#endif

static gdouble
interpolate (gdouble t, gdouble begin, gdouble end, double power)
{
  return (begin + (end - begin) * pow (t, power));
}

static void
interpolate_rectangle (gdouble		t,
		       WsRectangle *	from,
		       WsRectangle *	to,
		       WsRectangle *	result)
{
    if (!result)
	return;

    result->x = interpolate (t, from->x, to->x, 1);
    result->y = interpolate (t, from->y, to->y, 1);
    result->width = interpolate (t, from->width, to->width, 1);
    result->height = interpolate (t, from->height, to->height, 1);
}

typedef struct
{
    CmDrawableNode *node;
    GTimer *timer;

    MetaCompositor *compositor;
    ScreenInfo *scr_info;
    
    MetaMinimizeFinishedFunc finished_func;
    gpointer		     finished_data;

    gdouble	aspect_ratio;
    
    WsRectangle current_geometry;
    WsRectangle target_geometry;
    gdouble	 current_alpha;
    gdouble	 target_alpha;

    int		button_x;
    int		button_y;
    int		button_width;
    int		button_height;
    
    /* FIXME: maybe would be simpler if all of this was an array */
    gboolean phase_1_started;
    gboolean phase_2_started;
    gboolean phase_3_started;
    gboolean phase_4_started;
    gboolean phase_5_started;
} MiniInfo;

static void
set_geometry (MiniInfo *info, gdouble elapsed)
{
    WsRectangle rect;

    interpolate_rectangle (elapsed, &info->current_geometry, &info->target_geometry, &rect);

    g_print ("y: %d %d  (%f  => %d)\n", info->current_geometry.y, info->target_geometry.y,
	     elapsed, rect.y);
    
    g_print ("setting: %d %d %d %d\n", rect.x, rect.y, rect.width, rect.height);
    
    cm_drawable_node_set_geometry (info->node,
				   rect.x, rect.y,
				   rect.width, rect.height);
}

static int
center (gdouble what, gdouble in)
{
    return (in - what) / 2.0 + 0.5;
}

static void
run_phase_1 (MiniInfo *info, gdouble elapsed)
{
    if (!info->phase_1_started)
    {
	GList *next;
	g_print ("starting phase 1\n");
	info->phase_1_started = TRUE;

	info->current_geometry.x = info->node->real_x;
	info->current_geometry.y = info->node->real_y;
	info->current_geometry.width = info->node->real_width;
	info->current_geometry.height = info->node->real_height;

	info->target_geometry.height = info->button_height;
	info->target_geometry.width = info->button_height * info->aspect_ratio;
	info->target_geometry.x = info->button_x + center (info->target_geometry.width, info->button_width);
	info->target_geometry.y = info->node->real_y + center (info->button_height, info->node->real_height);

	handle_restacking (info->compositor, info->node,
			   info->scr_info->compositor_nodes->data);
    }

    set_geometry (info, elapsed);
}

static void
run_phase_2 (MiniInfo *info, gdouble elapsed)
{
#define WOBBLE_FACTOR 3
    
    if (!info->phase_2_started)
    {
	WsRectangle cur = info->target_geometry;

	g_print ("starting phase 2\n");

	info->phase_2_started = TRUE;
	
	info->current_geometry = cur;
	
	info->target_geometry.x = cur.x + center (WOBBLE_FACTOR * cur.width, cur.width);
	info->target_geometry.y = cur.y + center (WOBBLE_FACTOR * cur.height, cur.height);
	info->target_geometry.width = cur.width * WOBBLE_FACTOR;
	info->target_geometry.height = cur.height * WOBBLE_FACTOR;
    }

    set_geometry (info, elapsed);
}

static void
run_phase_3 (MiniInfo *info, gdouble elapsed)
{
    if (!info->phase_3_started)
    {
	WsRectangle cur = info->target_geometry;
	
	g_print ("starting phase 3\n");
	info->phase_3_started = TRUE;

	info->current_geometry = cur;

	info->target_geometry.height = info->button_height;
	info->target_geometry.width = info->button_height * info->aspect_ratio;
	info->target_geometry.x = info->button_x + center (info->target_geometry.width, info->button_width);
	info->target_geometry.y = info->node->real_y + center (info->button_height, info->node->real_height);
    }

    set_geometry (info, elapsed);
}

static void
run_phase_4 (MiniInfo *info, gdouble elapsed)
{
    if (!info->phase_4_started)
    {
	WsRectangle cur = info->target_geometry;
	
	g_print ("starting phase 4\n");
	info->phase_4_started = TRUE;

	info->current_geometry = cur;

	info->target_geometry.height = info->button_height;
	info->target_geometry.width = info->button_height * info->aspect_ratio;
	info->target_geometry.x = cur.x;
	g_print ("button y: %d\n", info->button_y);
	info->target_geometry.y = info->button_y;
    }

    set_geometry (info, elapsed);
}

static void
run_phase_5 (MiniInfo *info, gdouble elapsed)
{
    if (!info->phase_5_started)
    {
	WsRectangle cur = info->target_geometry;

	g_print ("starting phase 5\n");
	info->phase_5_started = TRUE;

	info->current_geometry = cur;
	info->target_geometry.x = info->button_x;
	info->target_geometry.y = info->button_y;
	info->target_geometry.width = info->button_width;
	info->target_geometry.height = info->button_height;
    }

    set_geometry (info, elapsed);

    cm_drawable_node_set_alpha (info->node, 1 - elapsed);
}

static gboolean
run_animation_01 (gpointer data)
{
    MiniInfo *info = data;
    gdouble elapsed;

    elapsed = g_timer_elapsed (info->timer, NULL);

#define PHASE_0		0.0
#define PHASE_1		0.225		/* scale to size of button */
#define PHASE_2		0.325		/* scale up a little */
#define PHASE_3		0.425		/* scale back a little */
#define PHASE_4		0.650		/* move to button */
#define PHASE_5		1.0		/* fade out */

    if (elapsed < PHASE_1)
    {
	/* phase one */
	run_phase_1 (info, (elapsed - PHASE_0)/(PHASE_1 - PHASE_0));
    }
    else if (elapsed < PHASE_2)
    {
	/* phase two */
	run_phase_2 (info, (elapsed - PHASE_1)/(PHASE_2 - PHASE_1));
    }
    else if (elapsed < PHASE_3)
    {
	/* phase three */
	run_phase_3 (info, (elapsed - PHASE_2)/(PHASE_3 - PHASE_2));
    }
    else if (elapsed < PHASE_4)
    {
	/* phase four */
	run_phase_4 (info, (elapsed - PHASE_3)/(PHASE_4 - PHASE_3));
    }
    else if (elapsed < PHASE_5)
    {
	/* phase five */
	run_phase_5 (info, (elapsed - PHASE_4)/(PHASE_5 - PHASE_4));
    }
    else 
    {
	cm_drawable_node_set_viewable (info->node, FALSE);

	cm_drawable_node_unset_geometry (info->node);
	
	cm_drawable_node_set_alpha (info->node, 1.0);
	
	if (info->finished_func)
	    info->finished_func (info->finished_data);

	return FALSE;
    }

    return TRUE;
}

#if 0
static gboolean
do_minimize_animation (gpointer data)
{
    MiniInfo *info = data;
    double elapsed;
    gboolean done = FALSE;

#define FADE_TIME 0.5

    elapsed = g_timer_elapsed (info->timer, NULL);
    elapsed = elapsed / FADE_TIME;
    
    if (elapsed >= 1.0)
    {
	elapsed = 1.0;
	done = TRUE;
    }

    g_print ("%f\n", elapsed);

    cm_drawable_node_set_geometry (info->node,
				   info->node->real_x + interpolate (elapsed, 0, info->node->real_width / 2, 1),
				   info->node->real_y + interpolate (elapsed, 0, info->node->real_height / 2, 1),
				   interpolate (elapsed, info->node->real_width, 0, 1),
				   interpolate (elapsed, info->node->real_height, 0, 1));

    if (done)
	return FALSE;
    
#if 0
    g_print ("inter: %f %f %f\n", 0, 735, interpolate (0.0, 735.0, 0.5, 1.0));
    
    g_print ("inter x .5: %f (%d %d)\n", info->node->real_x + interpolate (0, info->node->real_width / 2, .5, 1), 0, info->node->real_width);
#endif
    
    cm_drawable_node_set_alpha (info->node, 1 - elapsed);

    if (done)
    {
    }
    else
    {
	return TRUE;
    }
    
#if 0
    queue_repaint (info->node,
		   node_get_screen (info->window->display->xdisplay,
				    info->node));
#endif
}
#endif

static void
convert (MetaScreen *screen,
	 int x, int y, int width, int height,
	 DoubleRect *rect)
{
  rect->x = x / (double)screen->rect.width;
  rect->y = y / (double)screen->rect.height;
  rect->width = width / (double)screen->rect.width;
  rect->height = height / (double)screen->rect.height;
}
#endif /* HAVE_COMPOSITE_EXTENSIONS */

void
meta_compositor_minimize (MetaCompositor           *compositor,
			  MetaWindow               *window,
			  int                       x,
			  int                       y,
			  int                       width,
			  int                       height,
			  MetaMinimizeFinishedFunc  finished,
			  gpointer                  data)
{
#ifdef HAVE_COMPOSITE_EXTENSIONS
  MiniInfo *info = g_new (MiniInfo, 1);
  CmDrawableNode *node = window_to_node (compositor, window);
  WsRectangle start;
  MetaScreen *screen = window->screen;

  info->node = node;
  info->timer = g_timer_new ();

  info->finished_func = finished;
  info->finished_data = data;

  info->phase_1_started = FALSE;
  info->phase_2_started = FALSE;
  info->phase_3_started = FALSE;
  info->phase_4_started = FALSE;
  info->phase_5_started = FALSE;

  info->button_x = x;
  info->button_y = y;
  info->button_width = width;
  info->button_height = height;

  info->compositor = compositor;
  info->scr_info = screen->compositor_data;
  
#if 0
  cm_drawable_node_set_deformation_func (node, minimize_deformation, info);
#endif

  info->aspect_ratio = 1.3;
  
  g_idle_add (run_animation_01, info);
  
#endif
}