Introduce gesture frames

This patch extends the API with parallel new/delete functions,
aiming to eventually replace the open/close function. The new
functions give access to the grail gesture frames, containing
gestural transform information. This information is useful in its
own right, and will eventually replace the internal recognizer.

Signed-off-by: Henrik Rydberg <rydberg@euromail.se>

1 files changed, 241 insertions, 0 deletions

diff --git a/src/grail-init.c b/src/grail-init.c
new file mode 100644
index 0000000..18e6996
--- /dev/null
+++ b/src/grail-init.c
@@ -0,0 +1,241 @@
+/*****************************************************************************
+ *
+ * grail - Gesture Recognition And Instantiation Library
+ *
+ * Copyright (C) 2010 Canonical Ltd.
+ * Copyright (C) 2010 Henrik Rydberg <rydberg@bitmath.org>
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation, either version 3 of the License, or (at your
+ * option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ ****************************************************************************/
+
+#include "grail-impl.h"
+#include <stdlib.h>
+#include <string.h>
+#include <math.h>
+
+static struct grail_control *create_control(int size)
+{
+        struct grail_control *c = calloc(1, size);
+
+        if (!c)
+                return 0;
+
+        c->glue_ms = 60;
+        c->bar_center_x = 0.03;
+        c->bar_center_y = 0.03;
+        c->bar_drag_x = 0.03;
+        c->bar_drag_y = 0.03;
+        c->bar_scale = 0.3;
+        c->bar_angle = 0.1;
+        c->drop_x_ms = 300;
+        c->drop_y_ms = 300;
+        c->drop_scale_ms = 300;
+        c->drop_angle_ms = 300;
+
+        return c;
+}
+
+static void destroy_slots(struct grail_element **slots, int nslot)
+{
+        int i;
+
+        if (slots) {
+                for (i = nslot - 1; i >= 0; i--)
+                        free(slots[i]);
+                free(slots);
+        }
+}
+
+static void destroy_frame(struct grail_frame *frame, int nslot)
+{
+        if (frame) {
+                destroy_slots(frame->slots, nslot);
+                free(frame->ongoing);
+                free(frame);
+        }
+}
+
+static void destroy_frames(struct grail_frame **frames, int nframe, int nslot)
+{
+        int i;
+
+        if (frames) {
+                for (i = nframe - 1; i >= 0; i--)
+                        destroy_frame(frames[i], nslot);
+                free(frames);
+        }
+}
+
+static struct grail_element **create_slots(int nslot, int ntouch, int size)
+{
+        struct grail_element **slots;
+        struct grail_element *s;
+        int i;
+
+        slots = calloc(nslot, sizeof(slots[0]));
+        if (!slots)
+                return 0;
+
+        for (i = 0; i < nslot; i++) {
+                s = calloc(1, size + ntouch * sizeof(void *));
+                if (!s)
+                        goto out;
+                s->slot = i;
+                s->id = -1;
+                s->touches = (void *)((char *)s + size);
+                slots[i] = s;
+        }
+
+        return slots;
+ out:
+        destroy_slots(slots, nslot);
+        return 0;
+}
+
+static struct grail_frame *create_frame(int nslot, int ntouch,
+                                        int frame_size, int slot_size)
+{
+        struct grail_frame *frame;
+        int i;
+
+        frame = calloc(1, frame_size);
+        if (!frame)
+                return 0;
+
+        frame->ongoing = calloc(nslot, sizeof(frame->ongoing[0]));
+        frame->slots = create_slots(nslot, ntouch, slot_size);
+        if (!frame->ongoing || !frame->slots)
+                goto out;
+
+        return frame;
+ out:
+        destroy_frame(frame, nslot);
+        return 0;
+}
+
+static struct grail_frame **create_frames(int nframe, int nslot, int ntouch,
+                                          int frame_size, int slot_size)
+{
+        struct grail_frame **frames;
+        struct grail_frame *f;
+        int i;
+
+        frames = calloc(nframe, sizeof(frames[0]));
+        if (!frames)
+                return 0;
+
+        for (i = 0; i < nframe; i++) {
+                f = create_frame(nslot, ntouch, frame_size, slot_size);
+                if (!f)
+                        goto out;
+                frames[i] = f;
+        }
+
+        return frames;
+ out:
+        destroy_frames(frames, nframe, nslot);
+        return 0;
+}
+
+int create_grail2(struct grail_impl *x,
+                  utouch_frame_handle fh,
+                  unsigned int num_frames,
+                  grail_select_callback select,
+                  unsigned int version,
+                  unsigned int control_size,
+                  unsigned int frame_size,
+                  unsigned int slot_size)
+{
+        struct utouch_surface *s = utouch_frame_get_surface(fh);
+        unsigned int ntouch = utouch_frame_get_num_slots(fh);
+        unsigned int nslot = get_slot_count(ntouch);
+        int i, j;
+
+        x->select = select;
+        x->control_size = MAX(control_size, sizeof(struct grail_control));
+        x->frame_size = MAX(frame_size, sizeof(struct grail_frame));
+        x->slot_size = MAX(slot_size, sizeof(struct grail_element));
+
+        x->num_frames = num_frames;
+        x->num_slots = nslot;
+        x->num_touches = ntouch;
+
+        x->ctl = create_control(x->control_size);
+        if (!x->ctl)
+                goto freemem;
+
+        x->frames = create_frames(num_frames, nslot, ntouch,
+                                  x->frame_size, x->slot_size);
+        if (!x->frames)
+                goto freemem;
+
+        for (i = 0; i < num_frames; i++)
+                x->frames[(i + 1) % num_frames]->prev = x->frames[i];
+
+        return 0;
+
+ freemem:
+        destroy_grail2(x);
+        return -ENOMEM;
+}
+
+void destroy_grail2(struct grail_impl *x)
+{
+        destroy_frames(x->frames, x->num_frames, x->num_slots);
+        free(x->ctl);
+}
+
+grail_handle GRAIL_PUBLIC grail_new_raw(utouch_frame_handle fh,
+                                        unsigned int num_frames,
+                                        grail_select_callback select,
+                                        unsigned int version,
+                                        unsigned int control_size,
+                                        unsigned int frame_size,
+                                        unsigned int slot_size)
+{
+        struct grail *ge;
+        struct grail_impl *x;
+
+        ge = calloc(1, sizeof(*ge));
+        if (!ge)
+                return 0;
+        x = calloc(1, sizeof(*x));
+        if (!x)
+                goto out;
+        x->fh = fh;
+        if (create_grail2(x, fh, num_frames, select,
+                          version, control_size, frame_size, slot_size))
+                goto out;
+
+        ge->impl = x;
+        return ge;
+
+ out:
+        free(x);
+        free(ge);
+        return 0;
+}
+
+void GRAIL_PUBLIC grail_delete(grail_handle ge)
+{
+        destroy_grail2(ge->impl);
+        free(ge->impl);
+        free(ge);
+}
+
+struct grail_control GRAIL_PUBLIC *grail_get_control(grail_handle ge)
+{
+        return ge->impl->ctl;
+}