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;
+}