* edje: Make Edje_Real_Part_Drag a pointer. Win 100 bytes per states.

git-svn-id: svn+ssh://svn.enlightenment.org/var/svn/e/trunk/edje@41685 7cbeb6ba-43b4-40fd-8cce-4c39aea84d33

diff --git a/src/lib/edje_calc.c b/src/lib/edje_calc.c
index e7b374b..360b1a0 100644 (file)
--- a/src/lib/edje_calc.c
+++ b/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)
-     {
-       int offset;
-       int step;
-       double v;
 
-       /* complex dragable params */
-       if (flags & FLAG_X)
+   if (ep->drag)
+     {
+       /* 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;
-
-            offset = (ep->drag.x * (confine_to->w - params->w)) +
-              ep->drag.tmp.x;
-            if (ep->part->dragable.step_x > 0)
+            /* complex dragable params */
+            if (flags & FLAG_X)
               {
-                 params->x = confine_to->x +
-                   ((offset / ep->part->dragable.step_x) * ep->part->dragable.step_x);
+                 v = ep->drag->size.x * confine_to->w;
+
+                 if ((minw > 0) && (v < minw)) params->w = minw;
+                 else if ((maxw >= 0) && (v > maxw)) params->w = maxw;
+                 else params->w = 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;
               }
-            else if (ep->part->dragable.count_x > 0)
+            if (flags & FLAG_Y)
               {
-                 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;
+                 v = ep->drag->size.y * confine_to->h;
 
-            if ((minh > 0) && (v < minh)) params->h = minh;
-            else if ((maxh >= 0) && (v > maxh)) params->h = maxh;
-            else params->h = 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.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);
+                 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);
-              }
-            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)
-              {
-                 params->x = confine_to->x;
+                 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);
+                   }
               }
-            if ((params->x + params->w) > (confine_to->x + confine_to->w))
+            if (flags & FLAG_Y)
               {
-                 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 */
 
+   /* 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/src/lib/edje_callbacks.c b/src/lib/edje_callbacks.c
index 5a97aa0..84e3d58 100644 (file)
--- a/src/lib/edje_callbacks.c
+++ b/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);
+            rp = rp->drag->events_to;
+            if (!ignored)
+              {
+                 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)
+       if (rp->drag->down.count > 0)
          {
-            rp->drag.down.count--;
-            if (rp->drag.down.count == 0)
+            rp->drag->down.count--;
+            if (rp->drag->down.count == 0)
               {
-                 rp->drag.need_reset = 1;
+                 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/src/lib/edje_edit.c b/src/lib/edje_edit.c
index ca14bb8..fac0d24 100644 (file)
--- a/src/lib/edje_edit.c
+++ b/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/src/lib/edje_load.c b/src/lib/edje_load.c
index 6bafe83..6713e5a 100644 (file)
--- a/src/lib/edje_load.c
+++ b/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/src/lib/edje_private.h b/src/lib/edje_private.h
index 5bcffd5..d88ed5d 100644 (file)
--- a/src/lib/edje_private.h
+++ b/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/src/lib/edje_program.c b/src/lib/edje_program.c
index a04c4b0..0c5d234 100644 (file)
--- a/src/lib/edje_program.c
+++ b/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/src/lib/edje_util.c b/src/lib/edje_util.c
index 5f07fd4..77ecffa 100644 (file)
--- a/src/lib/edje_util.c
+++ b/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);
 }