diff --git a/e_effects.c b/e_effects.c
index e63fb6b..af11451 100644
--- a/e_effects.c
+++ b/e_effects.c
@@ -10,12 +10,13 @@ static Ecore_X_Window  input_window = 0;
 static Eina_List      *effects_windows = NULL;
 static Eina_List      *handlers = NULL;
 static Ecore_Animator *anim = NULL;
-static double          anim_time = 0.f;
+static double          anim_time = 0.0f;
 static double          anim_length = 0.33f;
 static int             revert = 0;
 static Ecore_Evas     *canvas = NULL;
 static E_Zone         *ref_zone = NULL;
 static Evas           *zone_evas = NULL;
+static Evas_Object    *bg = NULL;
 
 static void _place_windows();
 static int _e_effects_cb_key_down(void *data, int type, void *event);
@@ -34,7 +35,7 @@ EAPI int
 e_effects_shutdown(void)
 {
    if (effects_windows)
-      _e_revert_done();
+     _e_revert_done();
    return 1;
 }
 
@@ -42,18 +43,16 @@ EAPI void
 e_effects_apply(E_Zone * zone)
 {
    E_Desk *desk;
-
    E_Border_List *bl;
-
    E_Border *border;
 
    if (!ecore_x_composite_query())
-      return;
+     return;
    if (effects_windows)
-      return;
+     return;
    if (canvas)
-      return;
-
+     return;
+   
    E_OBJECT_CHECK(zone);
    desk = e_desk_current_get(zone);
    bl = e_container_border_list_first(desk->zone->container);
@@ -63,13 +62,65 @@ e_effects_apply(E_Zone * zone)
    e_object_ref(E_OBJECT(zone));
    canvas = e_canvas_new(E_EVAS_ENGINE_SOFTWARE_X11, zone->container->win,
 			 zone->x, zone->y, zone->w, zone->h, 1, 1, NULL);
-
+   /* RR: set title, name+class here, not per object */
+   ecore_evas_name_class_set(canvas, "E", "e_effects_object");
+   ecore_evas_title_set(canvas, "E Effects");
+   
    /* Yank the background from the zone and put it in our app instead
     * of a costly copy :-D. */
-   if (zone_evas)
+   /* RR: oh so bad. so so so bad. sooooooooooooo bad. SOOOOOOOOOOOOOOOOO bad.
+    * i don't know where to begin. 1. where are evas_object_release() and
+    * evas_object_inject() defined in any evas public header? they are not.
+    * they are not and never were public api calls. you should NEVER call
+    * non-exported calls. in fact if evas is compiled with visibility hidden
+    * (internal symbols removed from the symbol table) this code wont even
+    * work. you'll get symbol lookup errors on loading of the module. so
+    * first it's just bad to use internal symbols of a library. NEVER do it.
+    * 2. there isn't a costly copy - u simply load the same edje file as
+    * wallpaper is configured for that desktop... if that's what you want. 
+    * look at wallpaper config dialog code. create edje object, then set
+    * the file+group. it already has loaded and cached these objects and
+    * files. there isn't an expensive copy. a new instantiation of runtime
+    * data for the ejde object structure will be created from the already
+    * in-ram dat loaded from disk. the images are laready loaded and in ram
+    * for the wallpaper. they will simply be re-used from ram "as-is". a quick
+    * hash lookup and bingo. if, in the event, data cannot be copied (different
+    * formats, has been thrown away and different size cached) you would need
+    * to re-load anywa to get the original data back, so in the end the
+    * most efficent AND correct way is to re-create. not to mention objects
+    * are per canvas. if the engin3es vary each object can hold enigne private
+    * data. this will crash evas and the engines if you go moving an object
+    * from one canvas to another. even if they have the same engine, they may
+    * cache canvas specific data etc. this is all wrong is many ways.
+    * if (zone_evas)
+    * {
+    * evas_object_release(zone->bg_object, 0);
+    * evas_object_inject(zone->bg_object, ecore_evas_get(canvas));
+    * }
+    */
+   /* RR: correct code here short enough to give and an example */
      {
-	evas_object_release(zone->bg_object, 0);
-	evas_object_inject(zone->bg_object, ecore_evas_get(canvas));
+        const char *bgfile, *f;
+        Evas_Object *o;
+        
+        bgfile = e_bg_file_get(zone->container->num, zone->num,
+                               e_desk_current_get(zone)->x,
+                               e_desk_current_get(zone)->y);
+        o = edje_object_add(ecore_evas_get(canvas));
+        evas_object_move(o, 0, 0);
+        evas_object_resize(o, zone->w, zone->h);
+        if (bgfile)
+          {
+             edje_object_file_set(o, bgfile, "e/desktop/background");
+          }
+        else
+          {
+             f = e_theme_edje_file_get("base/theme/backgrounds",
+                                       "e/desktop/background");
+             edje_object_file_set(o, f, "e/desktop/background");
+          }
+        evas_object_show(o);
+        bg = o;
      }
 
    /* Build the list of affected windows */
@@ -79,23 +130,17 @@ e_effects_apply(E_Zone * zone)
 	if ((border->desk == desk) && (!border->iconic))
 	  {
 	     Eina_List *ll;
-
 	     E_Effects_Object *fx;
-
-	     int x, y;
-
-	     int w, h;
+	     int x, y, w, h;
 
 	     fx = e_effects_object_new(canvas, border,
 				       border->x, border->y,
 				       border->w, border->h);
-
 	     effects_windows = eina_list_append(effects_windows, fx);
 	  }
      }
-
    _place_windows(zone->w, zone->h);
-
+   
    /* Animations */
    revert = 0;
    if (!anim)
@@ -114,44 +159,43 @@ e_effects_apply(E_Zone * zone)
 	e_effects_revert();
 	return;
      }
-
+   
    handlers = eina_list_append
-      (handlers, ecore_event_handler_add
-       (ECORE_EVENT_KEY_DOWN, _e_effects_cb_key_down, NULL));
+     (handlers, ecore_event_handler_add
+      (ECORE_EVENT_KEY_DOWN, _e_effects_cb_key_down, NULL));
    handlers = eina_list_append
-      (handlers, ecore_event_handler_add
-       (ECORE_EVENT_MOUSE_BUTTON_DOWN, _e_effects_cb_mouse_down, NULL));
+     (handlers, ecore_event_handler_add
+      (ECORE_EVENT_MOUSE_BUTTON_DOWN, _e_effects_cb_mouse_down, NULL));
    handlers = eina_list_append
-      (handlers, ecore_event_handler_add
-       (ECORE_EVENT_MOUSE_WHEEL, _e_effects_cb_mouse_wheel, NULL));
+     (handlers, ecore_event_handler_add
+      (ECORE_EVENT_MOUSE_WHEEL, _e_effects_cb_mouse_wheel, NULL));
 }
 
 EAPI void
 e_effects_revert()
 {
    Eina_List *l;
-
    E_Effects_Object *data;
-
+   
    if (!effects_windows)
-      return;
+     return;
 
    /* Animations */
    EINA_LIST_FOREACH(effects_windows, l, data)
-   {
-      data->src_x = data->x;
-      data->dst_x = data->border->x;
-      data->delta_x = (float)(data->dst_x - data->x) / anim_length;
-      data->src_y = data->y;
-      data->dst_y = data->border->y;
-      data->delta_y = (float)(data->dst_y - data->y) / anim_length;
-      data->src_w = data->w;
-      data->dst_w = data->border->w;
-      data->delta_w = (float)(data->dst_w - data->w) / anim_length;
-      data->src_h = data->h;
-      data->dst_h = data->border->h;
-      data->delta_h = (float)(data->dst_h - data->h) / anim_length;
-   }
+     {
+        data->src_x = data->x;
+        data->dst_x = data->border->x - data->border->zone->x;
+        data->delta_x = (float)(data->dst_x - data->x) / anim_length;
+        data->src_y = data->y;
+        data->dst_y = data->border->y - data->border->zone->y;
+        data->delta_y = (float)(data->dst_y - data->y) / anim_length;
+        data->src_w = data->w;
+        data->dst_w = data->border->w;
+        data->delta_w = (float)(data->dst_w - data->w) / anim_length;
+        data->src_h = data->h;
+        data->dst_h = data->border->h;
+        data->delta_h = (float)(data->dst_h - data->h) / anim_length;
+     }
    revert = 1;
    if (!anim)
      {
@@ -164,35 +208,26 @@ static void
 _place_windows(int zone_width, int zone_height)
 {
    E_Effects_Object *data, *data2;
-
    Eina_List *l, *l2;
-
    int desk_x = 0;
-
    int desk_y = 0;
-
    int desk_w = zone_width;
-
    int desk_h = zone_height;
-
    int done = 0;
-
    float scale = 1.f;
-
    float scale_x, scale_y;
-
    int collision = 1;
 
    /* Initialize the windows */
    EINA_LIST_FOREACH(effects_windows, l, data)
-   {
-      e_effects_object_show(data);
-      data->dst_x = data->src_x = data->border->x;
-      data->dst_y = data->src_y = data->border->y;
-      data->dst_w = data->src_w = data->border->w;
-      data->dst_h = data->src_h = data->border->h;
-   }
-
+     {
+        e_effects_object_show(data);
+        data->dst_x = data->src_x = data->border->x - data->border->zone->x;
+        data->dst_y = data->src_y = data->border->y - data->border->zone->y;
+        data->dst_w = data->src_w = data->border->w;
+        data->dst_h = data->src_h = data->border->h;
+     }
+   
    while (!done)
      {
 	/* TODO
@@ -200,120 +235,116 @@ _place_windows(int zone_width, int zone_height)
 	 */
 	done = 1;
 	EINA_LIST_FOREACH(effects_windows, l, data)
-	{
-	   EINA_LIST_FOREACH(effects_windows, l2, data2)
-	   {
-	      collision = 1;
-
-	      /* check for a collision */
-	      if (data == data2 ||
-		  data->dst_x + data->dst_w <= data2->dst_x ||
-		  data->dst_x >= data2->dst_x + data2->dst_w ||
-		  data->dst_y + data->dst_h <= data2->dst_y ||
-		  data->dst_y >= data2->dst_y + data2->dst_h)
-		{
-		   collision = 0;
-		}
-
-	      /* if there is a collision calculate the centre position
-	       * and move the windows to the side closest to the center
-	       * of the screen which doesn't have a collision.
-	       */
-	      if (collision)
-		{
-		   float shortest_distance_squared = FLT_MAX;
-
-		   float distance_squared;
-
-		   int x, y;
-
-		   int fin_x = data2->dst_x;
-
-		   int fin_y = data2->dst_y;
-
-		   /* check bottom */
-		   x = data2->dst_x;
-		   y = data->dst_y + data->dst_h;
-		   distance_squared = (x - data2->src_x) * (x - data2->src_x)
-		      + (y - data2->src_y) * (y - data2->src_y);
-		   if (distance_squared < shortest_distance_squared &&
-		       (data->dst_x + data->dst_w <= x ||
-			data->dst_x >= x + data2->dst_w ||
-			data->dst_y + data->dst_h <= y ||
-			data->dst_y >= y + data2->dst_h))
-		     {
-			shortest_distance_squared = distance_squared;
-			fin_x = x;
-			fin_y = y;
-		     }
-
-		   /* check top */
-		   x = data2->dst_x;
-		   y = data->dst_y - data2->dst_h;
-		   distance_squared = (x - data2->src_x) * (x - data2->src_x)
-		      + (y - data2->src_y) * (y - data2->src_y);
-		   if (distance_squared < shortest_distance_squared &&
-		       (data->dst_x + data->dst_w <= x ||
-			data->dst_x >= x + data2->dst_w ||
-			data->dst_y + data->dst_h <= y ||
-			data->dst_y >= y + data2->dst_h))
-		     {
-			shortest_distance_squared = distance_squared;
-			fin_x = x;
-			fin_y = y;
-		     }
-
-		   /* check right */
-		   x = data->dst_x + data->dst_w;
-		   y = data2->dst_y;
-		   distance_squared = (x - data2->src_x) * (x - data2->src_x)
-		      + (y - data2->src_y) * (y - data2->src_y);
-		   if (distance_squared < shortest_distance_squared &&
-		       (data->dst_x + data->dst_w <= x ||
-			data->dst_x >= x + data2->dst_w ||
-			data->dst_y + data->dst_h <= y ||
-			data->dst_y >= y + data2->dst_h))
-		     {
-			shortest_distance_squared = distance_squared;
-			fin_x = x;
-			fin_y = y;
-		     }
-
-		   /* check left */
-		   x = data->dst_x - data2->dst_w;
-		   y = data2->dst_y;
-		   distance_squared = (x - data2->src_x) * (x - data2->src_x)
-		      + (y - data2->src_y) * (y - data2->src_y);
-		   if (distance_squared < shortest_distance_squared &&
-		       (data->dst_x + data->dst_w <= x ||
-			data->dst_x >= x + data2->dst_w ||
-			data->dst_y + data->dst_h <= y ||
-			data->dst_y >= y + data2->dst_h))
-		     {
-			shortest_distance_squared = distance_squared;
-			fin_x = x;
-			fin_y = y;
-		     }
-
-		   if (fin_x < desk_x)
-		      desk_x = fin_x;
-		   if (fin_y < desk_y)
-		      desk_y = fin_y;
-		   if (fin_x + data2->dst_w > desk_w)
-		      desk_w = fin_x + data2->dst_w;
-		   if (fin_y + data2->dst_h > desk_h)
-		      desk_h = fin_y + data2->dst_h;
-
-		   data2->dst_x = fin_x;
-		   data2->dst_y = fin_y;
-		}
-	   }
-	}
+          {
+             EINA_LIST_FOREACH(effects_windows, l2, data2)
+               {
+                  collision = 1;
+                  
+                  /* check for a collision */
+                  if (data == data2 ||
+                      data->dst_x + data->dst_w <= data2->dst_x ||
+                      data->dst_x >= data2->dst_x + data2->dst_w ||
+                      data->dst_y + data->dst_h <= data2->dst_y ||
+                      data->dst_y >= data2->dst_y + data2->dst_h)
+                    {
+                       collision = 0;
+                    }
+                  
+                  /* if there is a collision calculate the centre position
+                   * and move the windows to the side closest to the center
+                   * of the screen which doesn't have a collision.
+                   */
+                  if (collision)
+                    {
+                       float shortest_distance_squared = FLT_MAX;
+                       float distance_squared;
+                       int x, y;
+                       int fin_x = data2->dst_x;
+                       int fin_y = data2->dst_y;
+                       
+                       /* check bottom */
+                       x = data2->dst_x;
+                       y = data->dst_y + data->dst_h;
+                       distance_squared = (x - data2->src_x) * (x - data2->src_x)
+                         + (y - data2->src_y) * (y - data2->src_y);
+                       if (distance_squared < shortest_distance_squared &&
+                           (data->dst_x + data->dst_w <= x ||
+                            data->dst_x >= x + data2->dst_w ||
+                            data->dst_y + data->dst_h <= y ||
+                            data->dst_y >= y + data2->dst_h))
+                         {
+                            shortest_distance_squared = distance_squared;
+                            fin_x = x;
+                            fin_y = y;
+                         }
+                       
+                       /* check top */
+                       x = data2->dst_x;
+                       y = data->dst_y - data2->dst_h;
+                       distance_squared = (x - data2->src_x) * (x - data2->src_x)
+                         + (y - data2->src_y) * (y - data2->src_y);
+                       if (distance_squared < shortest_distance_squared &&
+                           (data->dst_x + data->dst_w <= x ||
+                            data->dst_x >= x + data2->dst_w ||
+                            data->dst_y + data->dst_h <= y ||
+                            data->dst_y >= y + data2->dst_h))
+                         {
+                            shortest_distance_squared = distance_squared;
+                            fin_x = x;
+                            fin_y = y;
+                         }
+                       
+                       /* check right */
+                       x = data->dst_x + data->dst_w;
+                       y = data2->dst_y;
+                       distance_squared = (x - data2->src_x) * (x - data2->src_x)
+                         + (y - data2->src_y) * (y - data2->src_y);
+                       if (distance_squared < shortest_distance_squared &&
+                           (data->dst_x + data->dst_w <= x ||
+                            data->dst_x >= x + data2->dst_w ||
+                            data->dst_y + data->dst_h <= y ||
+                            data->dst_y >= y + data2->dst_h))
+                         {
+                            shortest_distance_squared = distance_squared;
+                            fin_x = x;
+                            fin_y = y;
+                         }
+                       
+                       /* check left */
+                       x = data->dst_x - data2->dst_w;
+                       y = data2->dst_y;
+                       distance_squared = (x - data2->src_x) * (x - data2->src_x)
+                         + (y - data2->src_y) * (y - data2->src_y);
+                       if (distance_squared < shortest_distance_squared &&
+                           (data->dst_x + data->dst_w <= x ||
+                            data->dst_x >= x + data2->dst_w ||
+                            data->dst_y + data->dst_h <= y ||
+                            data->dst_y >= y + data2->dst_h))
+                         {
+                            shortest_distance_squared = distance_squared;
+                            fin_x = x;
+                            fin_y = y;
+                         }
+                       
+                       if (fin_x < desk_x)
+                         desk_x = fin_x;
+                       if (fin_y < desk_y)
+                         desk_y = fin_y;
+                       if (fin_x + data2->dst_w > desk_w)
+                         desk_w = fin_x + data2->dst_w;
+                       if (fin_y + data2->dst_h > desk_h)
+                         desk_h = fin_y + data2->dst_h;
+                       
+                       data2->dst_x = fin_x;
+                       data2->dst_y = fin_y;
+                    }
+               }
+          }
      }
-
+   
    scale_x = (float)zone_width / (float)(desk_w - desk_x);
    scale_y = (float)zone_height / (float)(desk_h - desk_y);
-
+   
    if (scale_x < scale_y)
      {
 	scale = scale_x;
@@ -322,25 +353,25 @@ _place_windows(int zone_width, int zone_height)
      {
 	scale = scale_y;
      }
-
+   
    /* set up the animation values */
    EINA_LIST_FOREACH(effects_windows, l, data)
-   {
-      data->dst_x -= desk_x;
-      data->dst_y -= desk_y;
-      data->dst_x *= scale;
-      data->dst_y *= scale;
-      data->dst_w *= scale;
-      data->dst_h *= scale;
-
-      data->delta_x = (data->dst_x - data->src_x) / anim_length;
-      data->delta_y = (data->dst_y - data->src_y) / anim_length;
-      data->delta_w = (data->dst_w - data->src_w) / anim_length;
-      data->delta_h = (data->dst_h - data->src_h) / anim_length;
-
-      /* hack so the objects get dirtied and drawn */
-      data->src_x++;
-   }
+     {
+        data->dst_x -= desk_x;
+        data->dst_y -= desk_y;
+        data->dst_x *= scale;
+        data->dst_y *= scale;
+        data->dst_w *= scale;
+        data->dst_h *= scale;
+        
+        data->delta_x = (data->dst_x - data->src_x) / anim_length;
+        data->delta_y = (data->dst_y - data->src_y) / anim_length;
+        data->delta_w = (data->dst_w - data->src_w) / anim_length;
+        data->delta_h = (data->dst_h - data->src_h) / anim_length;
+        
+        /* hack so the objects get dirtied and drawn */
+        data->src_x++;
+     }
 }
 
 static int
@@ -350,7 +381,7 @@ _e_effects_cb_key_down(void *data, int type, void *event)
 
    ev = event;
    if (!strcmp(ev->key, "space"))
-      e_effects_revert();
+     e_effects_revert();
    return 1;
 }
 
@@ -358,39 +389,34 @@ static int
 _e_effects_cb_mouse_down(void *unused, int type, void *event)
 {
    Evas *evas;
-
    Eina_List *l;
-
    Evas_Object *obj;
-
    E_Effects_Object *fx;
-
    E_Effects_Object *fx_under_mouse = NULL;
-
    Ecore_Event_Mouse_Button *ev;
 
    evas = ecore_evas_get(canvas);
    if (!evas)
-      return 0;
-
+     return 0;
+   
    ev = (Ecore_Event_Mouse_Button *) event;
    if (!ev)
-      return 0;
-
+     return 0;
+   
    /*
     * The following doesn't work for some reason
     * so we do it manually.
-    obj = evas_object_top_at_pointer_get(evas);
+    * obj = evas_object_top_at_pointer_get(evas);
     */
    EINA_LIST_FOREACH(effects_windows, l, fx)
-   {
-      if (fx->x <= ev->x &&
-	  fx->y <= ev->y && fx->x + fx->w >= ev->x && fx->y + fx->h >= ev->y)
-	{
-	   fx_under_mouse = fx;
-	}
-   }
-
+     {
+        if (fx->x <= ev->x &&
+            fx->y <= ev->y && fx->x + fx->w >= ev->x && fx->y + fx->h >= ev->y)
+          {
+             fx_under_mouse = fx;
+          }
+     }
+   
    if (fx_under_mouse)
      {
 	evas_object_raise(fx_under_mouse->img);
@@ -413,52 +439,45 @@ static int
 _e_effects_animate_cb(void *data)
 {
    Eina_List *fxs = NULL;
-
    Eina_List *l;
-
    E_Effects_Object *fx;
-
    int done = 1;
-
    double delta = ecore_loop_time_get() - anim_time;
-
+   
    if (!(fxs = data))
-      return 1;
-
+     return 1;
+   
    if (delta > anim_length)
      {
 	EINA_LIST_FOREACH(fxs, l, fx)
-	{
-	   e_effects_object_move_resize(fx,
-					fx->dst_x, fx->dst_y,
-					fx->dst_w, fx->dst_h);
-	}
-
+          {
+             e_effects_object_move_resize(fx,
+                                          fx->dst_x,
+                                          fx->dst_y,
+                                          fx->dst_w, fx->dst_h);
+          }
+        
 	if (revert)
 	  {
 	     _e_revert_done();
 	     revert = 0;
 	  }
-
+        
 	anim = NULL;
 	return 0;
      }
    else
      {
 	EINA_LIST_FOREACH(fxs, l, fx)
-	{
-	   int x = fx->src_x + (delta * fx->delta_x);
-
-	   int y = fx->src_y + (delta * fx->delta_y);
-
-	   int w = fx->src_w + (delta * fx->delta_w);
-
-	   int h = fx->src_h + (delta * fx->delta_h);
-
-	   e_effects_object_move_resize(fx, x, y, w, h);
-	}
+          {
+             int x = fx->src_x + (delta * fx->delta_x);
+             int y = fx->src_y + (delta * fx->delta_y);
+             int w = fx->src_w + (delta * fx->delta_w);
+             int h = fx->src_h + (delta * fx->delta_h);
+             
+             e_effects_object_move_resize(fx, x, y, w, h);
+          }
      }
-
    return 1;
 }
 
@@ -472,38 +491,41 @@ _e_revert_done()
 	/* Restore the background to the zone. */
 	if (zone_evas)
 	  {
-	     evas_object_release(ref_zone->bg_object, 0);
-	     evas_object_inject(ref_zone->bg_object, zone_evas);
+             /* RR: again - as per comments above with these calls. don't.
+              * use them. bad.
+              * evas_object_release(ref_zone->bg_object, 0);
+              * evas_object_inject(ref_zone->bg_object, zone_evas);
+              */
 	     zone_evas = NULL;
 	  }
-
 	e_object_unref(E_OBJECT(ref_zone));
 	ref_zone = NULL;
      }
-
+   
    if (canvas)
      {
 	e_canvas_del(canvas);
 	ecore_evas_free(canvas);
 	canvas = NULL;
+        /* RR: bg to null to as it gets deleted with the canvas */
+        bg = NULL;
      }
-
+   
    /* Restore inputs */
    while (handlers)
      {
 	ecore_event_handler_del(handlers->data);
 	handlers = eina_list_remove_list(handlers, handlers);
      }
-
+   
    e_grabinput_release(input_window, input_window);
    input_window = 0;
-
+   
    /* Restore the original windows */
    while (effects_windows)
      {
 	data = effects_windows->data;
 	effects_windows = eina_list_remove(effects_windows, data);
-
 	/* free memory */
 	e_object_del(E_OBJECT(data));
      }
diff --git a/e_effects_object.c b/e_effects_object.c
index 6fc07a3..8d12185 100644
--- a/e_effects_object.c
+++ b/e_effects_object.c
@@ -4,9 +4,14 @@
 #include <Ecore_X.h>
 #include "e_effects_object.h"
 
+/* RR: a smart object may have been nicer here. then evas_object_move/resize/show
+ * etc. would "just work" and it can be swallowed etc. i would say this is
+ * adequate, but not "optimal". i'd add points for optimal :)
+ */
+
 static void _e_effects_object_free(E_Effects_Object * fx);
 static void _e_effects_object_draw(E_Effects_Object * fx);
-static int _e_effects_x_error(Display * dpy, XErrorEvent * xerror);
+/* RR: static int _e_effects_x_error(Display * dpy, XErrorEvent * xerror); */
 static void _native_surface_update(E_Effects_Object * fx);
 static int _damage_cb(void *data, int type, void *event);
 
@@ -16,8 +21,17 @@ e_effects_object_new(Ecore_Evas * ee, E_Border * border, int x, int y,
 {
    E_Effects_Object *fx;
 
-   XSetErrorHandler(_e_effects_x_error);
-
+   /* RR: this sets the handler - but on shutdown on the module - it is not set back!
+    * no wonder things crtash. the rfunction on shutdown doesn't "exist" anymore.
+    * (technically this depends if the module is unloaded vs disabled but for
+    * now lets just say its unloaded - that means .so is dlcose()ed. the memory
+    * where this function lives exists no more. so at a minimum the error handler
+    * should be reset to what it was. as such ecore_x instals a "forgiving"
+    * error handler that just allows for errors and moves on to avoid the wm
+    * from crashing and exiting with xlib's default error handler. disable this
+    * as it serves no useful function
+    * XSetErrorHandler(_e_effects_x_error);
+    */
    fx = E_OBJECT_ALLOC(E_Effects_Object, E_EFFECTS_OBJECT_TYPE,
 		       _e_effects_object_free);
 
@@ -32,9 +46,12 @@ e_effects_object_new(Ecore_Evas * ee, E_Border * border, int x, int y,
    fx->h = h;
 
    fx->evas = ecore_evas_get(fx->ecore_evas);
-   ecore_evas_name_class_set(fx->ecore_evas, "E", "e_effects_object");
-   ecore_evas_title_set(fx->ecore_evas, "E Effects");
-
+   /* RR: why set it here per object?. do it in e_effects.c where canvas is
+    * created
+    * ecore_evas_name_class_set(fx->ecore_evas, "E", "e_effects_object");
+    * ecore_evas_title_set(fx->ecore_evas, "E Effects");
+    */
+   
    fx->border = border;
    fx->img = evas_object_image_add(fx->evas);
    evas_object_image_filled_set(fx->img, 1);
@@ -47,7 +64,6 @@ e_effects_object_new(Ecore_Evas * ee, E_Border * border, int x, int y,
 				   ecore_event_handler_add
 				   (ECORE_X_EVENT_DAMAGE_NOTIFY, _damage_cb,
 				    fx));
-
    return fx;
 }
 
@@ -137,17 +153,19 @@ _e_effects_object_draw(E_Effects_Object * fx)
    _native_surface_update(fx);
 }
 
-static int
-_e_effects_x_error(Display * dpy, XErrorEvent * xerror)
-{
-   char buf[PATH_MAX];
-
-   if (XGetErrorText(dpy, xerror->error_code, buf, PATH_MAX))
-     {
-	fprintf(stderr, "X ERROR %5d: %s\n", xerror->error_code, buf);
-     }
-   return 1;
-}
+/* RR:
+ * static int
+ * _e_effects_x_error(Display * dpy, XErrorEvent * xerror)
+ * {
+ * char buf[PATH_MAX];
+ *
+ * if (XGetErrorText(dpy, xerror->error_code, buf, PATH_MAX))
+ * {
+ * fprintf(stderr, "X ERROR %5d: %s\n", xerror->error_code, buf);
+ * }
+ * return 1;
+ * }
+ */
 
 static void
 _native_surface_update(E_Effects_Object * fx)
@@ -157,18 +175,42 @@ _native_surface_update(E_Effects_Object * fx)
    XImage *xim;
 
    evas_object_image_size_get(fx->img, &iw, &ih);
+   /* RR: get geometry. this is a round-trip (send message to server, wait
+    * for reply). there is no need. damaga event will have damaged region
+    * geometry. get that. */
    ecore_x_drawable_geometry_get(fx->pixmap, NULL, NULL, &pw, &ph);
+   /* RR: XGetImage? ewww. slow as balls. this 1. copies from video memory to
+    * system memory (server-side), then copies via a socket (unix or tcp) from
+    * xserver to client, then is copied from the client buffer to the ximage
+    * memory data buffer. all those copies... are BAD. not to mention, on
+    * update you copy the WHOLE pixmap. even if just a small region changed.
+    * damage events deliver the region of the pixmap that changed (and on
+    * first draw all of it will obviously).
+    * 
+    * solution here is:
+    * 1. XGetImage only if XShmGetImage fails.
+    * 2. only get the regions that changed.
+    * 3. only copy the changed regions to the image
+    * 4. handle any format conversions if pixmap is not ARGB32 (same as
+    *    evas image)
+    * 
+    * btw - i'm willing to let the region updatye slip as this was specifically
+    * "expose" and as such u will get a whole window contents each time. the
+    * shm stuff tho i think is a must. any windows animating/redrawing tho will
+    * cause some nasty cpu usage and slowness by getting the whole window
+    */
    xim = XGetImage(ecore_x_display_get(), fx->pixmap, 0, 0,
 		   pw, ph, AllPlanes, ZPixmap);
-   evas_object_size_hint_request_set(evas_object_smart_parent_get(fx->img), pw,
-				     ph);
-
-   evas_object_image_data_update_add(fx->img, 0, 0, iw, ih);
+   /* RR: move this up here - abore early if image get fails */
    if (!xim)
      {
 	printf("No X Image :-(\n");
 	return;
      }
+   evas_object_size_hint_request_set(evas_object_smart_parent_get(fx->img), pw,
+				     ph);
+
+   evas_object_image_data_update_add(fx->img, 0, 0, iw, ih);
 
    if ((pw != iw) || (ph != ih))
      {
@@ -197,6 +239,30 @@ _native_surface_update(E_Effects_Object * fx)
 	      * Make sure they are both ARGB instead of assuming if
 	      * they are not, do something smart like a convertion.
 	      */
+             /* RR: yet another copy :( remember. pixel data is huge. especially
+              * when updates happen. excess copies KILL system performance. EFL
+              * generally is fast because it avoids copies of big data. it 
+              * wastes some time with extra structs and alloc/dealloc of them
+              * etc. but focuses on the big meat. this pipeline from above
+              * is pretty bad performance-wise and it's noticable. a long
+              * pause before the expose window open. this was the idea of the
+              * in -evas native surface code you didn't manage to get going
+              * in time. try and unify the pixmap and the image data to
+              * minimise copies (eg for software enigne turn the image data
+              * into a sysvshm segment and to gets to the right section with
+              * the right bytes_per_line etc. to make sure you "fill in" just
+              * the updated regions. if the visual is not argb32 a copy (
+              * conversion) is needed, but u still use a small sysvshm image
+              * for just that update, for gl and xrender this get and
+              * possible conversion can be avoided by using the pixmap directly
+              * in xrender and with GL the texturefrompixmap extention if
+              * available (if not - do the same as software code, then upload
+              * sub-texture changes. no need to make the whole image a shm
+              * segment here as the upload will take place anyway).
+              * 
+              * even if you got just 1 engine working right (software) and
+              * gl/xrender (etc.) not working yet, that'd have been good! :)
+              */
 	     memcpy(data, xim->data, size);
 #if 0
 	     Evas_Native_Surface ns;
@@ -220,15 +286,15 @@ static int
 _damage_cb(void *data, int type, void *event)
 {
    E_Effects_Object *fx;
-
    Ecore_X_Event_Damage *ev;
 
    if (!(fx = data))
-      return 1;
+     return 1;
    if (!(ev = event))
-      return 1;
+     return 1;
+   /* RR: you don't use the damage region (x, y, w, h)!!! */
    if (fx->border->win != ev->drawable)
-      return 1;
+     return 1;
    _native_surface_update(fx);
    return 1;
 }
diff --git a/e_effects_object.h b/e_effects_object.h
index 74baad3..39e96c9 100644
--- a/e_effects_object.h
+++ b/e_effects_object.h
@@ -15,14 +15,16 @@
 #include <X11/extensions/Xdamage.h>
 #include <X11/extensions/Xrender.h>
 
-typedef struct _E_Effects_Object
+typedef struct _E_Effects_Object E_Effects_Object;
+
+struct _E_Effects_Object
 {
    E_Object e_obj_inherit;
-
+   
    Eina_List *handlers;
    int x, y, w, h;
    int visible;
-
+   
    int src_x, src_y;
    int dst_x, dst_y;
    int src_w, src_h;
@@ -36,7 +38,7 @@ typedef struct _E_Effects_Object
    Evas_Object *img;
    Ecore_X_Pixmap pixmap;
    Ecore_X_Damage damage;
-} E_Effects_Object;
+};
 
 EAPI E_Effects_Object *e_effects_object_new(Ecore_Evas * ee, E_Border * border,
 					    int x, int y, int w, int h);
diff --git a/e_mod_main.c b/e_mod_main.c
index d543f25..70a5b43 100644
--- a/e_mod_main.c
+++ b/e_mod_main.c
@@ -2,22 +2,18 @@
 #include "e_mod_main.h"
 
 /* actual module specifics */
-static void _e_mod_action_exebuf_cb(E_Object * obj, const char *params);
-
+static void _e_mod_action_effects_cb(E_Object * obj, const char *params);
 static int _e_mod_run_defer_cb(void *data);
-
 static void _e_mod_run_cb(void *data, E_Menu * m, E_Menu_Item * mi);
-
 static void _e_mod_menu_add(void *data, E_Menu * m);
 
 static E_Module *conf_module = NULL;
-
 static E_Action *act = NULL;
 
 /* module setup */
 EAPI E_Module_Api e_modapi = {
    E_MODULE_API_VERSION,
-   "Effects"
+     "Effects"
 };
 
 EAPI void *
@@ -25,22 +21,27 @@ e_modapi_init(E_Module * m)
 {
    conf_module = m;
 
-   if (!e_config->use_composite)
-     {
-	e_config->use_composite = 1;
-	e_config_save_queue();
-     }
-
+   /* RR: this is wrong i think. e_config->use_composite just makes e use
+    * ARGB32 visuals (thus an alpha channel instead of shaped window). it
+    * doesn't turn on compositing (composite manager) in any way, so disable.
+    * there isn't a NEED to turn it on
+    * if (!e_config->use_composite)
+    * {
+    * e_config->use_composite = 1;
+    * e_config_save_queue();
+    * }
+    */
+   e_effects_init();
+   
    /* add module supplied action */
    act = e_action_add("effects");
    if (act)
      {
-	act->func.go = _e_mod_action_exebuf_cb;
-	e_action_predef_name_set("Launch", "Effects", "effects", NULL, NULL, 0);
+	act->func.go = _e_mod_action_effects_cb;
+	e_action_predef_name_set(D_("Window : List"), D_("Effects"), "effects", 
+                                 NULL, NULL, 0);
      }
-
    e_module_delayed_set(m, 1);
-   e_effects_init();
    return m;
 }
 
@@ -50,7 +51,7 @@ e_modapi_shutdown(E_Module * m)
    /* remove module-supplied menu additions */
    if (act)
      {
-	e_action_predef_name_del("Launch", "Effects");
+	e_action_predef_name_del(D_("Window : List"), D_("Effects"));
 	e_action_del("effects");
 	act = NULL;
      }
@@ -68,25 +69,25 @@ e_modapi_save(E_Module * m)
 
 /* action callback */
 static void
-_e_mod_action_exebuf_cb(E_Object * obj, const char *params)
+_e_mod_action_effects_cb(E_Object * obj, const char *params)
 {
    E_Zone *zone = NULL;
 
    if (obj)
      {
 	if (obj->type == E_MANAGER_TYPE)
-	   zone = e_util_zone_current_get((E_Manager *) obj);
+          zone = e_util_zone_current_get((E_Manager *) obj);
 	else if (obj->type == E_CONTAINER_TYPE)
-	   zone = e_util_zone_current_get(((E_Container *) obj)->manager);
+          zone = e_util_zone_current_get(((E_Container *) obj)->manager);
 	else if (obj->type == E_ZONE_TYPE)
-	   zone = e_util_zone_current_get(((E_Zone *) obj)->container->manager);
+          zone = e_util_zone_current_get(((E_Zone *) obj)->container->manager);
 	else
-	   zone = e_util_zone_current_get(e_manager_current_get());
+          zone = e_util_zone_current_get(e_manager_current_get());
      }
-
+   
    if (!zone)
-      zone = e_util_zone_current_get(e_manager_current_get());
-
+     zone = e_util_zone_current_get(e_manager_current_get());
+   
    if (zone)
-      e_effects_apply(zone);
+     e_effects_apply(zone);
 }
diff --git a/e_mod_main.h b/e_mod_main.h
index 4a83541..1db27df 100644
--- a/e_mod_main.h
+++ b/e_mod_main.h
@@ -1,12 +1,11 @@
 #ifndef E_MOD_MAIN_H
 #define E_MOD_MAIN_H
 
-EAPI extern E_Module_Api e_modapi;
+#define D_(str) dgettext(PACKAGE, str)
 
+EAPI extern E_Module_Api e_modapi;
 EAPI void *e_modapi_init(E_Module * m);
-
 EAPI int e_modapi_shutdown(E_Module * m);
-
 EAPI int e_modapi_save(E_Module * m);
 
 #endif
