diff --git a/legacy/edje/src/lib/edje_calc.c b/legacy/edje/src/lib/edje_calc.c
index e7b374ba56..360b1a074e 100644
--- a/legacy/edje/src/lib/edje_calc.c
+++ b/legacy/edje/src/lib/edje_calc.c
@@ -196,9 +196,9 @@ _edje_recalc_do(Edje *ed)
 int
 _edje_part_dragable_calc(Edje *ed, Edje_Real_Part *ep, double *x, double *y)
 {
-   if ((ep->part->dragable.x != 0) || (ep->part->dragable.y != 0))
+   if (ep->drag)
      {
-	if (ep->drag.confine_to)
+	if (ep->drag->confine_to)
 	  {
 	     double dx, dy, dw, dh;
 	     int ret = 0;
@@ -208,13 +208,13 @@ _edje_part_dragable_calc(Edje *ed, Edje_Real_Part *ep, double *x, double *y)
 	     else if (ep->part->dragable.x != 0) ret = 1;
 	     else if (ep->part->dragable.y != 0) ret = 2;
 
-	     dx = ep->x - ep->drag.confine_to->x;
-	     dw = ep->drag.confine_to->w - ep->w;
+	     dx = ep->x - ep->drag->confine_to->x;
+	     dw = ep->drag->confine_to->w - ep->w;
 	     if (dw != 0.0) dx /= dw;
 	     else dx = 0.0;
 
-	     dy = ep->y - ep->drag.confine_to->y;
-	     dh = ep->drag.confine_to->h - ep->h;
+	     dy = ep->y - ep->drag->confine_to->y;
+	     dh = ep->drag->confine_to->h - ep->h;
 	     if (dh != 0) dy /= dh;
 	     else dy = 0.0;
 
@@ -225,8 +225,8 @@ _edje_part_dragable_calc(Edje *ed, Edje_Real_Part *ep, double *x, double *y)
 	  }
 	else
 	  {
-	     if (x) *x = (double)(ep->drag.tmp.x + ep->drag.x);
-	     if (y) *y = (double)(ep->drag.tmp.y + ep->drag.y);
+	     if (x) *x = (double)(ep->drag->tmp.x + ep->drag->x);
+	     if (y) *y = (double)(ep->drag->tmp.y + ep->drag->y);
 	     return 0;
 	  }
      }
@@ -240,26 +240,26 @@ void
 _edje_dragable_pos_set(Edje *ed, Edje_Real_Part *ep, double x, double y)
 {
    /* check whether this part is dragable at all */
-   if (!ep->part->dragable.x && !ep->part->dragable.y) return;
+   if (!ep->drag) return ;
 
    /* instead of checking for equality, we really should check that
     * the difference is greater than foo, but I have no idea what
     * value we would set foo to, because it would depend on the
     * size of the dragable...
     */
-   if (ep->drag.x != x || ep->drag.tmp.x)
+   if (ep->drag->x != x || ep->drag->tmp.x)
      {
-	ep->drag.x = x;
-	ep->drag.tmp.x = 0;
-	ep->drag.need_reset = 0;
+	ep->drag->x = x;
+	ep->drag->tmp.x = 0;
+	ep->drag->need_reset = 0;
 	ed->dirty = 1;
      }
 
-   if (ep->drag.y != y || ep->drag.tmp.y)
+   if (ep->drag->y != y || ep->drag->tmp.y)
      {
-	ep->drag.y = y;
-	ep->drag.tmp.y = 0;
-	ep->drag.need_reset = 0;
+	ep->drag->y = y;
+	ep->drag->tmp.y = 0;
+	ep->drag->need_reset = 0;
 	ed->dirty = 1;
      }
 
@@ -950,106 +950,110 @@ _edje_part_recalc_single(Edje *ed,
 	       }
 	  }
      }
-   /* confine */
-   if (confine_to)
+
+   if (ep->drag)
      {
-	int offset;
-	int step;
-	double v;
-
-	/* complex dragable params */
-	if (flags & FLAG_X)
+	/* confine */
+	if (confine_to)
 	  {
-	     v = ep->drag.size.x * confine_to->w;
+	     int offset;
+	     int step;
+	     double v;
 
-	     if ((minw > 0) && (v < minw)) params->w = minw;
-	     else if ((maxw >= 0) && (v > maxw)) params->w = maxw;
-	     else params->w = v;
+	     /* complex dragable params */
+	     if (flags & FLAG_X)
+	       {
+		  v = ep->drag->size.x * confine_to->w;
 
-	     offset = (ep->drag.x * (confine_to->w - params->w)) +
-	       ep->drag.tmp.x;
-	     if (ep->part->dragable.step_x > 0)
-	       {
-		  params->x = confine_to->x +
-		    ((offset / ep->part->dragable.step_x) * ep->part->dragable.step_x);
-	       }
-	     else if (ep->part->dragable.count_x > 0)
-	       {
-		  step = (confine_to->w - params->w) / ep->part->dragable.count_x;
-		  if (step < 1) step = 1;
-		  params->x = confine_to->x +
-		    ((offset / step) * step);
-	       }
-	     params->req_drag.x = params->x;
-	     params->req_drag.w = params->w;
-	  }
-	if (flags & FLAG_Y)
-	  {
-	     v = ep->drag.size.y * confine_to->h;
+		  if ((minw > 0) && (v < minw)) params->w = minw;
+		  else if ((maxw >= 0) && (v > maxw)) params->w = maxw;
+		  else params->w = v;
 
-	     if ((minh > 0) && (v < minh)) params->h = minh;
-	     else if ((maxh >= 0) && (v > maxh)) params->h = maxh;
-	     else params->h = v;
+		  offset = (ep->drag->x * (confine_to->w - params->w)) +
+		    ep->drag->tmp.x;
+		  if (ep->part->dragable.step_x > 0)
+		    {
+		       params->x = confine_to->x +
+			 ((offset / ep->part->dragable.step_x) * ep->part->dragable.step_x);
+		    }
+		  else if (ep->part->dragable.count_x > 0)
+		    {
+		       step = (confine_to->w - params->w) / ep->part->dragable.count_x;
+		       if (step < 1) step = 1;
+		       params->x = confine_to->x +
+			 ((offset / step) * step);
+		    }
+		  params->req_drag.x = params->x;
+		  params->req_drag.w = params->w;
+	       }
+	     if (flags & FLAG_Y)
+	       {
+		  v = ep->drag->size.y * confine_to->h;
 
-	     offset = (ep->drag.y * (confine_to->h - params->h)) +
-	       ep->drag.tmp.y;
-	     if (ep->part->dragable.step_y > 0)
-	       {
-		  params->y = confine_to->y +
-		    ((offset / ep->part->dragable.step_y) * ep->part->dragable.step_y);
+		  if ((minh > 0) && (v < minh)) params->h = minh;
+		  else if ((maxh >= 0) && (v > maxh)) params->h = maxh;
+		  else params->h = v;
+
+		  offset = (ep->drag->y * (confine_to->h - params->h)) +
+		    ep->drag->tmp.y;
+		  if (ep->part->dragable.step_y > 0)
+		    {
+		       params->y = confine_to->y +
+			 ((offset / ep->part->dragable.step_y) * ep->part->dragable.step_y);
+		    }
+		  else if (ep->part->dragable.count_y > 0)
+		    {
+		       step = (confine_to->h - params->h) / ep->part->dragable.count_y;
+		       if (step < 1) step = 1;
+		       params->y = confine_to->y +
+			 ((offset / step) * step);
+		    }
+		  params->req_drag.y = params->y;
+		  params->req_drag.h = params->h;
 	       }
-	     else if (ep->part->dragable.count_y > 0)
+	     /* limit to confine */
+	     if (flags & FLAG_X)
 	       {
-		  step = (confine_to->h - params->h) / ep->part->dragable.count_y;
-		  if (step < 1) step = 1;
-		  params->y = confine_to->y +
-		    ((offset / step) * step);
+		  if (params->x < confine_to->x)
+		    {
+		       params->x = confine_to->x;
+		    }
+		  if ((params->x + params->w) > (confine_to->x + confine_to->w))
+		    {
+		       params->x = confine_to->x + (confine_to->w - params->w);
+		    }
 	       }
-	     params->req_drag.y = params->y;
-	     params->req_drag.h = params->h;
-	  }
-	/* limit to confine */
-	if (flags & FLAG_X)
-	  {
-	     if (params->x < confine_to->x)
+	     if (flags & FLAG_Y)
 	       {
-		  params->x = confine_to->x;
-	       }
-	     if ((params->x + params->w) > (confine_to->x + confine_to->w))
-	       {
-		  params->x = confine_to->x + (confine_to->w - params->w);
+		  if (params->y < confine_to->y)
+		    {
+		       params->y = confine_to->y;
+		    }
+		  if ((params->y + params->h) > (confine_to->y + confine_to->h))
+		    {
+		       params->y = confine_to->y + (confine_to->h - params->h);
+		    }
 	       }
 	  }
-	if (flags & FLAG_Y)
+	else
 	  {
-	     if (params->y < confine_to->y)
+	     /* simple dragable params */
+	     if (flags & FLAG_X)
 	       {
-		  params->y = confine_to->y;
+		  params->x += ep->drag->x + ep->drag->tmp.x;
+		  params->req_drag.x = params->x;
+		  params->req_drag.w = params->w;
 	       }
-	     if ((params->y + params->h) > (confine_to->y + confine_to->h))
+	     if (flags & FLAG_Y)
 	       {
-		  params->y = confine_to->y + (confine_to->h - params->h);
+		  params->y += ep->drag->y + ep->drag->tmp.y;
+		  params->req_drag.y = params->y;
+		  params->req_drag.h = params->h;
 	       }
 	  }
      }
-   else
-     {
-	/* simple dragable params */
-	if (flags & FLAG_X)
-	  {
-	     params->x += ep->drag.x + ep->drag.tmp.x;
-	     params->req_drag.x = params->x;
-	     params->req_drag.w = params->w;
-	  }
-	if (flags & FLAG_Y)
-	  {
-	     params->y += ep->drag.y + ep->drag.tmp.y;
-	     params->req_drag.y = params->y;
-	     params->req_drag.h = params->h;
-	  }
-     }
+
    /* fill */
-
    if (ep->part->type == EDJE_PART_TYPE_GRADIENT && desc->gradient.use_rel && (!desc->gradient.type || !strcmp(desc->gradient.type, "linear")))
      {
 	int x2, y2;
@@ -1404,6 +1408,7 @@ _edje_part_recalc(Edje *ed, Edje_Real_Part *ep, int flags)
 #endif
    Edje_Calc_Params *p1, *pf;
    Edje_Part_Description *chosen_desc;
+   Edje_Real_Part *confine_to = NULL;
    double pos = 0.0;
 
    if ((ep->calculated & FLAG_XY) == FLAG_XY)
@@ -1509,11 +1514,12 @@ _edje_part_recalc(Edje *ed, Edje_Real_Part *ep, int flags)
 #endif
 	  }
      }
-   if (ep->drag.confine_to)
+   if (ep->drag && ep->drag->confine_to)
      {
-	_edje_part_recalc(ed, ep->drag.confine_to, flags);
+	confine_to = ep->drag->confine_to;
+	_edje_part_recalc(ed, confine_to, flags);
 #ifdef EDJE_CALC_CACHE
-	statec = ep->drag.confine_to->state;
+	statec = confine_to->state;
 #endif
      }
 //   if (ep->text.source)       _edje_part_recalc(ed, ep->text.source, flags);
@@ -1546,7 +1552,7 @@ _edje_part_recalc(Edje *ed, Edje_Real_Part *ep, int flags)
  	  {
  	     _edje_part_recalc_single(ed, ep, ep->param1.description, chosen_desc,
  				      ep->param1.rel1_to_x, ep->param1.rel1_to_y, ep->param1.rel2_to_x, ep->param1.rel2_to_y,
- 				      ep->drag.confine_to,
+ 				      confine_to,
  				      p1,
  				      flags);
 #ifdef EDJE_CALC_CACHE
@@ -1576,7 +1582,7 @@ _edje_part_recalc(Edje *ed, Edje_Real_Part *ep, int flags)
  	  {
  	     _edje_part_recalc_single(ed, ep, ep->param2.description, chosen_desc,
  				      ep->param2.rel1_to_x, ep->param2.rel1_to_y, ep->param2.rel2_to_x, ep->param2.rel2_to_y,
- 				      ep->drag.confine_to,
+ 				      confine_to,
 				      p2,
  				      flags);
 #ifdef EDJE_CALC_CACHE
@@ -1685,18 +1691,18 @@ _edje_part_recalc(Edje *ed, Edje_Real_Part *ep, int flags)
 #endif
    ep->req = pf->req;
 
-   if (ep->drag.need_reset)
+   if (ep->drag && ep->drag->need_reset)
      {
 	double dx, dy;
 
 	dx = 0;
 	dy = 0;
 	_edje_part_dragable_calc(ed, ep, &dx, &dy);
-        ep->drag.x = dx;
-	ep->drag.y = dy;
-	ep->drag.tmp.x = 0;
-	ep->drag.tmp.y = 0;
-	ep->drag.need_reset = 0;
+        ep->drag->x = dx;
+	ep->drag->y = dy;
+	ep->drag->tmp.x = 0;
+	ep->drag->tmp.y = 0;
+	ep->drag->need_reset = 0;
      }
    if (!ed->calc_only)
      {
diff --git a/legacy/edje/src/lib/edje_callbacks.c b/legacy/edje/src/lib/edje_callbacks.c
index 5a97aa0303..84e3d58d8f 100644
--- a/legacy/edje/src/lib/edje_callbacks.c
+++ b/legacy/edje/src/lib/edje_callbacks.c
@@ -89,25 +89,25 @@ _edje_mouse_down_cb(void *data, Evas * e, Evas_Object * obj, void *event_info)
 	_edje_emit(ed, buf, rp->part->name);
      }
 
-   if (rp->drag.events_to)
+   if (rp->drag && rp->drag->events_to)
      {
 	int x = 0, y = 0;
 	Edje_Real_Part *events;
 
-	events = rp->drag.events_to;
+	events = rp->drag->events_to;
 	evas_object_geometry_get(rp->object, &x, &y, NULL, NULL);
 
 	if ((events->part->dragable.x) || (events->part->dragable.y))
 	  {
 	     if (events->part->dragable.x)
 	       {
-		  events->drag.down.x = ev->canvas.x;
-		  events->drag.tmp.x = 0;
+		  events->drag->down.x = ev->canvas.x;
+		  events->drag->tmp.x = 0;
 	       }
 	     if (events->part->dragable.y)
 	       {
-		  events->drag.down.y = ev->canvas.y;
-		  events->drag.tmp.y = 0;
+		  events->drag->down.y = ev->canvas.y;
+		  events->drag->tmp.y = 0;
 	       }
 
 	     if (!ignored)
@@ -134,17 +134,17 @@ _edje_mouse_down_cb(void *data, Evas * e, Evas_Object * obj, void *event_info)
 
 	     dir = _edje_part_dragable_calc(ed, rp, &dx, &dy);
 	     
-	     if ((dx != rp->drag.val.x) || (dy != rp->drag.val.y))
+	     if ((dx != rp->drag->val.x) || (dy != rp->drag->val.y))
 	       {
-		  rp->drag.val.x = dx;
-		  rp->drag.val.y = dy;
+		  rp->drag->val.x = dx;
+		  rp->drag->val.y = dy;
 		  if (!ignored)
 		    _edje_emit(ed, "drag", rp->part->name);
 		  ed->dirty = 1;
 #ifdef EDJE_CALC_CACHE
 		  rp->invalidate = 1;
 #endif
-		  rp->drag.need_reset = 1;
+		  rp->drag->need_reset = 1;
 		  _edje_recalc_do(ed);
 	       }
 	  }
@@ -152,16 +152,16 @@ _edje_mouse_down_cb(void *data, Evas * e, Evas_Object * obj, void *event_info)
 
    if ((rp->part->dragable.x) || (rp->part->dragable.y))
      {
-	if (rp->drag.down.count == 0)
+	if (rp->drag->down.count == 0)
 	  {
 	     if (rp->part->dragable.x)
-		 rp->drag.down.x = ev->canvas.x;
+		 rp->drag->down.x = ev->canvas.x;
 	     if (rp->part->dragable.y)
-		 rp->drag.down.y = ev->canvas.y;
+		 rp->drag->down.y = ev->canvas.y;
 	     if (!ignored)
 	       _edje_emit(ed, "drag,start", rp->part->name);
 	  }
-	rp->drag.down.count++;
+	rp->drag->down.count++;
      }
    if (rp->clicked_button == 0)
      {
@@ -200,24 +200,24 @@ _edje_mouse_up_cb(void *data, Evas * e, Evas_Object * obj, void *event_info)
 	_edje_emit(ed, buf, rp->part->name);
      }
 
-   if (rp->drag.events_to)
+   if (rp->drag)
      {
-	rp = rp->drag.events_to;
-	if (!ignored)
+	if (rp->drag->events_to)
 	  {
-	     snprintf(buf, sizeof(buf), "mouse,up,%i", ev->button);
-	     _edje_emit(ed, buf, rp->part->name);
-	  }
-     }
-
-   if ((rp->part->dragable.x) || (rp->part->dragable.y))
-     {
-	if (rp->drag.down.count > 0)
-	  {
-	     rp->drag.down.count--;
-	     if (rp->drag.down.count == 0)
+	     rp = rp->drag->events_to;
+	     if (!ignored)
 	       {
-		  rp->drag.need_reset = 1;
+		  snprintf(buf, sizeof(buf), "mouse,up,%i", ev->button);
+		  _edje_emit(ed, buf, rp->part->name);
+	       }
+	  }
+
+	if (rp->drag->down.count > 0)
+	  {
+	     rp->drag->down.count--;
+	     if (rp->drag->down.count == 0)
+	       {
+		  rp->drag->need_reset = 1;
 		  ed->dirty = 1;
 #ifdef EDJE_CALC_CACHE
 		  rp->invalidate = 1;
@@ -227,6 +227,7 @@ _edje_mouse_up_cb(void *data, Evas * e, Evas_Object * obj, void *event_info)
 	       }
 	  }
      }
+
    if ((rp->still_in) && (rp->clicked_button == ev->button) && (!ignored))
      {
 	snprintf(buf, sizeof(buf), "mouse,clicked,%i", ev->button);
@@ -254,7 +255,7 @@ _edje_mouse_move_cb(void *data, Evas * e, Evas_Object * obj, void *event_info)
    ed = data;
    rp = evas_object_data_get(obj, "real_part");
    if (!rp) return;
-   if (rp->drag.events_to) rp = rp->drag.events_to;
+   if (rp->drag && rp->drag->events_to) rp = rp->drag->events_to;
 
    ignored = rp->part->ignore_flags & ev->event_flags;
 
@@ -281,33 +282,31 @@ _edje_mouse_move_cb(void *data, Evas * e, Evas_Object * obj, void *event_info)
 	  rp->still_in = 1;
      }
    _edje_freeze(ed);
-   if ((rp->part->dragable.x) || (rp->part->dragable.y))
+   if (rp->drag)
      {
-	if (rp->drag.down.count > 0)
+	if (rp->drag->down.count > 0)
 	  {
 	     if (rp->part->dragable.x)
-	       rp->drag.tmp.x = ev->cur.canvas.x - rp->drag.down.x;
+	       rp->drag->tmp.x = ev->cur.canvas.x - rp->drag->down.x;
 	     if (rp->part->dragable.y)
-	       rp->drag.tmp.y = ev->cur.canvas.y - rp->drag.down.y;
+	       rp->drag->tmp.y = ev->cur.canvas.y - rp->drag->down.y;
 	     ed->dirty = 1;
 #ifdef EDJE_CALC_CACHE
 	     rp->invalidate = 1;
 #endif
 	  }
 	_edje_recalc_do(ed);
-     }
-   if ((rp->part->dragable.x) || (rp->part->dragable.y))
-     {
-	if (rp->drag.down.count > 0)
+
+	if (rp->drag->down.count > 0)
 	  {
 	     double dx, dy;
 	     int dir;
 
 	     dir = _edje_part_dragable_calc(ed, rp, &dx, &dy);
-	     if ((dx != rp->drag.val.x) || (dy != rp->drag.val.y))
+	     if ((dx != rp->drag->val.x) || (dy != rp->drag->val.y))
 	       {
-		  rp->drag.val.x = dx;
-		  rp->drag.val.y = dy;
+		  rp->drag->val.x = dx;
+		  rp->drag->val.y = dy;
 		  if (!ignored)
 		    _edje_emit(ed, "drag", rp->part->name);
 		  ed->dirty = 1;
diff --git a/legacy/edje/src/lib/edje_edit.c b/legacy/edje/src/lib/edje_edit.c
index ca14bb8f2f..fac0d24762 100644
--- a/legacy/edje/src/lib/edje_edit.c
+++ b/legacy/edje/src/lib/edje_edit.c
@@ -1549,8 +1549,6 @@ edje_edit_part_add(Evas_Object *obj, const char* name, unsigned char type)
 	  }
 	evas_object_clip_set(rp->object, ed->clipper);
      }
-   rp->drag.step.x = ep->dragable.step_x;
-   rp->drag.step.y = ep->dragable.step_y;
    rp->gradient_id = -1;
 
 
@@ -1937,6 +1935,21 @@ edje_edit_part_drag_x_set(Evas_Object *obj, const char *part, int drag)
    GET_RP_OR_RETURN();
    printf("Set dragX for part: %s\n", part);
    rp->part->dragable.x = drag;
+
+   if (!drag && !rp->part->dragable.y)
+     {
+	free(rp->drag);
+	rp->drag = NULL;
+	return ;
+     }
+
+   if (rp->drag) return;
+
+   rp->drag = mem_alloc(sizeof (Edje_Real_Part_Drag));
+   if (!rp->drag) return;
+
+   rp->drag->step.x = rp->part->dragable.step_x;
+   rp->drag->step.y = rp->part->dragable.step_y;
 }
 
 EAPI int
@@ -1953,6 +1966,21 @@ edje_edit_part_drag_y_set(Evas_Object *obj, const char *part, int drag)
    GET_RP_OR_RETURN();
    printf("Set dragY for part: %s\n", part);
    rp->part->dragable.y = drag;
+
+   if (!drag && !rp->part->dragable.x)
+     {
+	free(rp->drag);
+	rp->drag = NULL;
+	return ;
+     }
+
+   if (rp->drag) return;
+
+   rp->drag = mem_alloc(sizeof (Edje_Real_Part_Drag));
+   if (!rp->drag) return;
+
+   rp->drag->step.x = rp->part->dragable.step_x;
+   rp->drag->step.y = rp->part->dragable.step_y;
 }
 
 EAPI int
diff --git a/legacy/edje/src/lib/edje_load.c b/legacy/edje/src/lib/edje_load.c
index 6bafe83702..6713e5a2d4 100644
--- a/legacy/edje/src/lib/edje_load.c
+++ b/legacy/edje/src/lib/edje_load.c
@@ -352,6 +352,21 @@ _edje_object_file_set_internal(Evas_Object *obj, const char *file, const char *g
 		       ed->load_error = EDJE_LOAD_ERROR_RESOURCE_ALLOCATION_FAILED;
 		       return 0;
 		    }
+
+		  if ((ep->dragable.x != 0) || (ep->dragable.y != 0))
+		    {
+		       rp->drag = calloc(1, sizeof (Edje_Real_Part_Drag));
+		       if (!rp->drag)
+			 {
+			    ed->load_error = EDJE_LOAD_ERROR_RESOURCE_ALLOCATION_FAILED;
+			    free(rp);
+			    return 0;
+			 }
+
+		       rp->drag->step.x = ep->dragable.step_x;
+		       rp->drag->step.y = ep->dragable.step_y;
+		    }
+
 		  rp->edje = ed;
 		  _edje_ref(rp->edje);
 		  rp->part = ep;
@@ -424,8 +439,6 @@ _edje_object_file_set_internal(Evas_Object *obj, const char *file, const char *g
 		       if (rp->part->clip_to_id < 0)
 			 evas_object_clip_set(rp->object, ed->clipper);
 		    }
-		  rp->drag.step.x = ep->dragable.step_x;
-		  rp->drag.step.y = ep->dragable.step_y;
 		  rp->gradient_id = -1;
 	       }
 	     if (n > 0)
@@ -462,20 +475,23 @@ _edje_object_file_set_internal(Evas_Object *obj, const char *file, const char *g
 				 evas_object_clip_set(rp->object, rp->clip_to->object);
 			      }
 			 }
-		       if (rp->part->dragable.confine_id >= 0)
-			 rp->drag.confine_to = ed->table_parts[rp->part->dragable.confine_id % ed->table_parts_size];
-		       
-		       /* replay events for dragable */
-		       if (rp->part->dragable.events_id >= 0)
+		       if (rp->drag)
 			 {
-			    rp->drag.events_to =
-			      ed->table_parts[rp->part->dragable.events_id % ed->table_parts_size];
-			    /* events_to may be used only with dragable */
-			    if (!rp->drag.events_to->part->dragable.x &&
-				!rp->drag.events_to->part->dragable.y)
-			      rp->drag.events_to = NULL;
+			    if (rp->part->dragable.confine_id >= 0)
+			      rp->drag->confine_to = ed->table_parts[rp->part->dragable.confine_id % ed->table_parts_size];
+
+			    /* replay events for dragable */
+			    if (rp->part->dragable.events_id >= 0)
+			      {
+				 rp->drag->events_to =
+				   ed->table_parts[rp->part->dragable.events_id % ed->table_parts_size];
+				 /* events_to may be used only with dragable */
+				 if (!rp->drag->events_to->part->dragable.x &&
+				     !rp->drag->events_to->part->dragable.y)
+				   rp->drag->events_to = NULL;
+			      }
 			 }
-		       
+
 		       rp->swallow_params.min.w = 0;
 		       rp->swallow_params.min.w = 0;
 		       rp->swallow_params.max.w = -1;
@@ -527,9 +543,12 @@ _edje_object_file_set_internal(Evas_Object *obj, const char *file, const char *g
 		  rp = ed->table_parts[i];
 		  evas_object_show(rp->object);
 		  if (_edje_block_break(ed)) break;
-		  if (rp->part->dragable.x < 0) rp->drag.val.x = 1.0;
-		  if (rp->part->dragable.y < 0) rp->drag.val.x = 1.0;
-		  _edje_dragable_pos_set(ed, rp, rp->drag.val.x, rp->drag.val.y);
+		  if (rp->drag)
+		    {
+		       if (rp->part->dragable.x < 0) rp->drag->val.x = 1.0;
+		       if (rp->part->dragable.y < 0) rp->drag->val.x = 1.0;
+		       _edje_dragable_pos_set(ed, rp, rp->drag->val.x, rp->drag->val.y);
+		    }
 	       }
 	     ed->dirty = 1;
 #ifdef EDJE_CALC_CACHE
diff --git a/legacy/edje/src/lib/edje_private.h b/legacy/edje/src/lib/edje_private.h
index 5bcffd5219..d88ed5d6f5 100644
--- a/legacy/edje/src/lib/edje_private.h
+++ b/legacy/edje/src/lib/edje_private.h
@@ -808,7 +808,7 @@ struct _Edje_Real_Part
       Edje_Aspect aspect; // 12
    } swallow_params; // 28 // FIXME: only if type SWALLOW
 
-   Edje_Real_Part_Drag drag; // 104 // FIME: make drag pointer to struct optional
+   Edje_Real_Part_Drag      *drag; // 4
 
    struct {
       Edje_Real_Part        *source; // 4
@@ -856,8 +856,8 @@ struct _Edje_Real_Part
 #ifdef EDJE_CALC_CACHE
    unsigned char             invalidate : 1;
 #endif
-}; //  394
-// WITH EDJE_CALC_CACHE: 874
+}; //  294
+// WITH EDJE_CALC_CACHE: 774
 
 struct _Edje_Running_Program
 {
diff --git a/legacy/edje/src/lib/edje_program.c b/legacy/edje/src/lib/edje_program.c
index a04c4b0eeb..0c5d2342e4 100644
--- a/legacy/edje/src/lib/edje_program.c
+++ b/legacy/edje/src/lib/edje_program.c
@@ -671,15 +671,15 @@ _edje_program_run(Edje *ed, Edje_Program *pr, int force, const char *ssig, const
 	     if (pt->id >= 0)
 	       {
 		  rp = ed->table_parts[pt->id % ed->table_parts_size];
-		  if ((rp) && (rp->drag.down.count == 0))
+		  if ((rp) && (rp->drag) && (rp->drag->down.count == 0))
 		    {
-		       rp->drag.val.x = pr->value;
-		       rp->drag.val.y = pr->value2;
-		       if      (rp->drag.val.x < 0.0) rp->drag.val.x = 0.0;
-		       else if (rp->drag.val.x > 1.0) rp->drag.val.x = 1.0;
-		       if      (rp->drag.val.y < 0.0) rp->drag.val.y = 0.0;
-		       else if (rp->drag.val.y > 1.0) rp->drag.val.y = 1.0;
-		       _edje_dragable_pos_set(ed, rp, rp->drag.val.x, rp->drag.val.y);
+		       rp->drag->val.x = pr->value;
+		       rp->drag->val.y = pr->value2;
+		       if      (rp->drag->val.x < 0.0) rp->drag->val.x = 0.0;
+		       else if (rp->drag->val.x > 1.0) rp->drag->val.x = 1.0;
+		       if      (rp->drag->val.y < 0.0) rp->drag->val.y = 0.0;
+		       else if (rp->drag->val.y > 1.0) rp->drag->val.y = 1.0;
+		       _edje_dragable_pos_set(ed, rp, rp->drag->val.x, rp->drag->val.y);
 		       _edje_emit(ed, "drag,set", rp->part->name);
 		       if (_edje_block_break(ed)) goto break_prog;
 		    }
@@ -697,15 +697,15 @@ _edje_program_run(Edje *ed, Edje_Program *pr, int force, const char *ssig, const
 	     if (pt->id >= 0)
 	       {
 		  rp = ed->table_parts[pt->id % ed->table_parts_size];
-		  if ((rp) && (rp->drag.down.count == 0))
+		  if ((rp) && (rp->drag) && (rp->drag->down.count == 0))
 		    {
-		       rp->drag.val.x += pr->value * rp->drag.step.x * rp->part->dragable.x;
-		       rp->drag.val.y += pr->value2 * rp->drag.step.y * rp->part->dragable.y;
-		       if      (rp->drag.val.x < 0.0) rp->drag.val.x = 0.0;
-		       else if (rp->drag.val.x > 1.0) rp->drag.val.x = 1.0;
-		       if      (rp->drag.val.y < 0.0) rp->drag.val.y = 0.0;
-		       else if (rp->drag.val.y > 1.0) rp->drag.val.y = 1.0;
-		       _edje_dragable_pos_set(ed, rp, rp->drag.val.x, rp->drag.val.y);
+		       rp->drag->val.x += pr->value * rp->drag->step.x * rp->part->dragable.x;
+		       rp->drag->val.y += pr->value2 * rp->drag->step.y * rp->part->dragable.y;
+		       if      (rp->drag->val.x < 0.0) rp->drag->val.x = 0.0;
+		       else if (rp->drag->val.x > 1.0) rp->drag->val.x = 1.0;
+		       if      (rp->drag->val.y < 0.0) rp->drag->val.y = 0.0;
+		       else if (rp->drag->val.y > 1.0) rp->drag->val.y = 1.0;
+		       _edje_dragable_pos_set(ed, rp, rp->drag->val.x, rp->drag->val.y);
 		       _edje_emit(ed, "drag,step", rp->part->name);
 		       if (_edje_block_break(ed)) goto break_prog;
 		    }
@@ -723,15 +723,15 @@ _edje_program_run(Edje *ed, Edje_Program *pr, int force, const char *ssig, const
 	     if (pt->id >= 0)
 	       {
 		  rp = ed->table_parts[pt->id % ed->table_parts_size];
-		  if ((rp) && (rp->drag.down.count == 0))
+		  if ((rp) && (rp->drag) && (rp->drag->down.count == 0))
 		    {
-		       rp->drag.val.x += pr->value * rp->drag.page.x * rp->part->dragable.x;
-		       rp->drag.val.y += pr->value2 * rp->drag.page.y * rp->part->dragable.y;
-		       if      (rp->drag.val.x < 0.0) rp->drag.val.x = 0.0;
-		       else if (rp->drag.val.x > 1.0) rp->drag.val.x = 1.0;
-		       if      (rp->drag.val.y < 0.0) rp->drag.val.y = 0.0;
-		       else if (rp->drag.val.y > 1.0) rp->drag.val.y = 1.0;
-		       _edje_dragable_pos_set(ed, rp, rp->drag.val.x, rp->drag.val.y);
+		       rp->drag->val.x += pr->value * rp->drag->page.x * rp->part->dragable.x;
+		       rp->drag->val.y += pr->value2 * rp->drag->page.y * rp->part->dragable.y;
+		       if      (rp->drag->val.x < 0.0) rp->drag->val.x = 0.0;
+		       else if (rp->drag->val.x > 1.0) rp->drag->val.x = 1.0;
+		       if      (rp->drag->val.y < 0.0) rp->drag->val.y = 0.0;
+		       else if (rp->drag->val.y > 1.0) rp->drag->val.y = 1.0;
+		       _edje_dragable_pos_set(ed, rp, rp->drag->val.x, rp->drag->val.y);
 		       _edje_emit(ed, "drag,page", rp->part->name);
 		       if (_edje_block_break(ed)) goto break_prog;
 		    }
diff --git a/legacy/edje/src/lib/edje_util.c b/legacy/edje/src/lib/edje_util.c
index 5f07fd48de..77ecffaa79 100644
--- a/legacy/edje/src/lib/edje_util.c
+++ b/legacy/edje/src/lib/edje_util.c
@@ -2156,7 +2156,8 @@ edje_object_part_drag_value_set(Evas_Object *obj, const char *part, double dx, d
    if ((!ed) || (!part)) return;
    rp = _edje_real_part_recursive_get(ed, (char *)part);
    if (!rp) return;
-   if (rp->drag.down.count > 0) return;
+   if (!rp->drag) return;
+   if (rp->drag->down.count > 0) return;
    if (rp->part->dragable.confine_id != -1)
      {
 	dx = CLAMP(dx, 0.0, 1.0);
@@ -2164,9 +2165,9 @@ edje_object_part_drag_value_set(Evas_Object *obj, const char *part, double dx, d
      }
    if (rp->part->dragable.x < 0) dx = 1.0 - dx;
    if (rp->part->dragable.y < 0) dy = 1.0 - dy;
-   if ((rp->drag.val.x == dx) && (rp->drag.val.y == dy)) return;
-   rp->drag.val.x = dx;
-   rp->drag.val.y = dy;
+   if ((rp->drag->val.x == dx) && (rp->drag->val.y == dy)) return;
+   rp->drag->val.x = dx;
+   rp->drag->val.y = dy;
 #ifdef EDJE_CALC_CACHE
    rp->invalidate = 1;
 #endif
@@ -2202,14 +2203,14 @@ edje_object_part_drag_value_get(const Evas_Object *obj, const char *part, double
    _edje_recalc_do(ed);
 
    rp = _edje_real_part_recursive_get(ed, (char *)part);
-   if (!rp)
+   if (!rp || !rp->drag)
      {
 	if (dx) *dx = 0;
 	if (dy) *dy = 0;
 	return;
      }
-   ddx = rp->drag.val.x;
-   ddy = rp->drag.val.y;
+   ddx = rp->drag->val.x;
+   ddy = rp->drag->val.y;
    if (rp->part->dragable.x < 0) ddx = 1.0 - ddx;
    if (rp->part->dragable.y < 0) ddy = 1.0 - ddy;
    if (dx) *dx = ddx;
@@ -2234,13 +2235,14 @@ edje_object_part_drag_size_set(Evas_Object *obj, const char *part, double dw, do
    if ((!ed) || (!part)) return;
    rp = _edje_real_part_recursive_get(ed, (char *)part);
    if (!rp) return;
+   if (!rp->drag) return;
    if (dw < 0.0) dw = 0.0;
    else if (dw > 1.0) dw = 1.0;
    if (dh < 0.0) dh = 0.0;
    else if (dh > 1.0) dh = 1.0;
-   if ((rp->drag.size.x == dw) && (rp->drag.size.y == dh)) return;
-   rp->drag.size.x = dw;
-   rp->drag.size.y = dh;
+   if ((rp->drag->size.x == dw) && (rp->drag->size.y == dh)) return;
+   rp->drag->size.x = dw;
+   rp->drag->size.y = dh;
    rp->edje->dirty = 1;
 #ifdef EDJE_CALC_CACHE
    rp->invalidate = 1;
@@ -2274,14 +2276,14 @@ edje_object_part_drag_size_get(const Evas_Object *obj, const char *part, double
    _edje_recalc_do(ed);
 
    rp = _edje_real_part_recursive_get(ed, (char *)part);
-   if (!rp)
+   if (!rp || !rp->drag)
      {
 	if (dw) *dw = 0;
 	if (dh) *dh = 0;
 	return;
      }
-   if (dw) *dw = rp->drag.size.x;
-   if (dh) *dh = rp->drag.size.y;
+   if (dw) *dw = rp->drag->size.x;
+   if (dh) *dh = rp->drag->size.y;
 }
 
 /** Sets the drag step increment
@@ -2302,12 +2304,13 @@ edje_object_part_drag_step_set(Evas_Object *obj, const char *part, double dx, do
    if ((!ed) || (!part)) return;
    rp = _edje_real_part_recursive_get(ed, (char *)part);
    if (!rp) return;
+   if (!rp->drag) return;
    if (dx < 0.0) dx = 0.0;
    else if (dx > 1.0) dx = 1.0;
    if (dy < 0.0) dy = 0.0;
    else if (dy > 1.0) dy = 1.0;
-   rp->drag.step.x = dx;
-   rp->drag.step.y = dy;
+   rp->drag->step.x = dx;
+   rp->drag->step.y = dy;
 #ifdef EDJE_CALC_CACHE
    rp->invalidate = 1;
 #endif
@@ -2339,14 +2342,14 @@ edje_object_part_drag_step_get(const Evas_Object *obj, const char *part, double
    _edje_recalc_do(ed);
 
    rp = _edje_real_part_recursive_get(ed, (char *)part);
-   if (!rp)
+   if (!rp || !rp->drag)
      {
 	if (dx) *dx = 0;
 	if (dy) *dy = 0;
 	return;
      }
-   if (dx) *dx = rp->drag.step.x;
-   if (dy) *dy = rp->drag.step.y;
+   if (dx) *dx = rp->drag->step.x;
+   if (dy) *dy = rp->drag->step.y;
 }
 
 /** Sets the page step increments
@@ -2367,12 +2370,13 @@ edje_object_part_drag_page_set(Evas_Object *obj, const char *part, double dx, do
    if ((!ed) || (!part)) return;
    rp = _edje_real_part_recursive_get(ed, (char *)part);
    if (!rp) return;
+   if (!rp->drag) return;
    if (dx < 0.0) dx = 0.0;
    else if (dx > 1.0) dx = 1.0;
    if (dy < 0.0) dy = 0.0;
    else if (dy > 1.0) dy = 1.0;
-   rp->drag.page.x = dx;
-   rp->drag.page.y = dy;
+   rp->drag->page.x = dx;
+   rp->drag->page.y = dy;
 #ifdef EDJE_CALC_CACHE
    rp->invalidate = 1;
 #endif
@@ -2404,14 +2408,14 @@ edje_object_part_drag_page_get(const Evas_Object *obj, const char *part, double
    _edje_recalc_do(ed);
 
    rp = _edje_real_part_recursive_get(ed, (char *)part);
-   if (!rp)
+   if (!rp || !rp->drag)
      {
 	if (dx) *dx = 0;
 	if (dy) *dy = 0;
 	return;
      }
-   if (dx) *dx = rp->drag.page.x;
-   if (dy) *dy = rp->drag.page.y;
+   if (dx) *dx = rp->drag->page.x;
+   if (dy) *dy = rp->drag->page.y;
 }
 
 /** Steps the dragable x,y steps
@@ -2434,18 +2438,19 @@ edje_object_part_drag_step(Evas_Object *obj, const char *part, double dx, double
    if ((!ed) || (!part)) return;
    rp = _edje_real_part_recursive_get(ed, (char *)part);
    if (!rp) return;
-   if (rp->drag.down.count > 0) return;
-   px = rp->drag.val.x;
-   py = rp->drag.val.y;
-   rp->drag.val.x += dx * rp->drag.step.x * rp->part->dragable.x;
-   rp->drag.val.y += dy * rp->drag.step.y * rp->part->dragable.y;
-   rp->drag.val.x = CLAMP (rp->drag.val.x, 0.0, 1.0);
-   rp->drag.val.y = CLAMP (rp->drag.val.y, 0.0, 1.0);
-   if ((px == rp->drag.val.x) && (py == rp->drag.val.y)) return;
+   if (!rp->drag) return;
+   if (rp->drag->down.count > 0) return;
+   px = rp->drag->val.x;
+   py = rp->drag->val.y;
+   rp->drag->val.x += dx * rp->drag->step.x * rp->part->dragable.x;
+   rp->drag->val.y += dy * rp->drag->step.y * rp->part->dragable.y;
+   rp->drag->val.x = CLAMP (rp->drag->val.x, 0.0, 1.0);
+   rp->drag->val.y = CLAMP (rp->drag->val.y, 0.0, 1.0);
+   if ((px == rp->drag->val.x) && (py == rp->drag->val.y)) return;
 #ifdef EDJE_CALC_CACHE
    rp->invalidate = 1;
 #endif
-   _edje_dragable_pos_set(rp->edje, rp, rp->drag.val.x, rp->drag.val.y);
+   _edje_dragable_pos_set(rp->edje, rp, rp->drag->val.x, rp->drag->val.y);
    _edje_emit(rp->edje, "drag,step", rp->part->name);
 }
 
@@ -2469,18 +2474,19 @@ edje_object_part_drag_page(Evas_Object *obj, const char *part, double dx, double
    if ((!ed) || (!part)) return;
    rp = _edje_real_part_recursive_get(ed, (char *)part);
    if (!rp) return;
-   if (rp->drag.down.count > 0) return;
-   px = rp->drag.val.x;
-   py = rp->drag.val.y;
-   rp->drag.val.x += dx * rp->drag.page.x * rp->part->dragable.x;
-   rp->drag.val.y += dy * rp->drag.page.y * rp->part->dragable.y;
-   rp->drag.val.x = CLAMP (rp->drag.val.x, 0.0, 1.0);
-   rp->drag.val.y = CLAMP (rp->drag.val.y, 0.0, 1.0);
-   if ((px == rp->drag.val.x) && (py == rp->drag.val.y)) return;
+   if (!rp->drag) return;
+   if (rp->drag->down.count > 0) return;
+   px = rp->drag->val.x;
+   py = rp->drag->val.y;
+   rp->drag->val.x += dx * rp->drag->page.x * rp->part->dragable.x;
+   rp->drag->val.y += dy * rp->drag->page.y * rp->part->dragable.y;
+   rp->drag->val.x = CLAMP (rp->drag->val.x, 0.0, 1.0);
+   rp->drag->val.y = CLAMP (rp->drag->val.y, 0.0, 1.0);
+   if ((px == rp->drag->val.x) && (py == rp->drag->val.y)) return;
 #ifdef EDJE_CALC_CACHE
    rp->invalidate = 1;
 #endif
-   _edje_dragable_pos_set(rp->edje, rp, rp->drag.val.x, rp->drag.val.y);
+   _edje_dragable_pos_set(rp->edje, rp, rp->drag->val.x, rp->drag->val.y);
    _edje_emit(rp->edje, "drag,page", rp->part->name);
 }