gphoto4ruby 0.1.6 → 0.2.0

data/ext/gphoto2camera.h

@@ -0,0 +1,66 @@
+/**
+ *
+ * Copyright 2008 neq4 company <http://neq4.com>
+ * Author: Sergey Kruk <sergey.kruk@gmail.com>
+ *
+ * This file is part of GPhoto4Ruby.
+ *
+ * GPhoto4Ruby is free software: you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation, either
+ * version 3 of the License, or (at your option) any later version.
+ *
+ * GPhoto4Ruby 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 GPhoto4Ruby. If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <fcntl.h>
+#include <string.h>
+#include <gphoto2/gphoto2.h>
+#include <ruby.h>
+#include "gphoto2camera_event.h"
+#include "gphoto2camera_utilities.h"
+
+#ifndef _INC_CAMERA
+#define _INC_CAMERA
+
+VALUE rb_mGPhoto2;
+VALUE rb_cGPhoto2Camera;
+
+VALUE rb_cGPhoto2ConfigurationError;
+
+void camera_mark(GPhoto2Camera *c);
+void camera_free(GPhoto2Camera *c);
+VALUE camera_allocate(VALUE klass);
+
+VALUE camera_initialize(int argc, VALUE *argv, VALUE self);
+VALUE camera_class_ports(VALUE klass);
+
+VALUE camera_capture(int argc, VALUE *argv, VALUE self);
+
+VALUE camera_save(int argc, VALUE *argv, VALUE self);
+VALUE camera_delete(int argc, VALUE *argv, VALUE self);
+
+VALUE camera_get_config(VALUE self);
+VALUE camera_config_merge(VALUE self, VALUE hash);
+
+VALUE camera_get_value(int argc, VALUE *argv, VALUE self);
+VALUE camera_set_value(VALUE self, VALUE str, VALUE newVal);
+
+VALUE camera_folder(VALUE self);
+VALUE camera_subfolders(VALUE self);
+VALUE camera_files(VALUE self);
+VALUE camera_folder_up(VALUE self);
+VALUE camera_folder_down(VALUE self, VALUE folder);
+
+VALUE camera_wait(int argc, VALUE *argv, VALUE self);
+
+#endif /* _INC_CAMERA */

data/ext/gphoto2camera_event.c

@@ -0,0 +1,94 @@
+/**
+ *
+ * Copyright 2008 neq4 company <http://neq4.com>
+ * Author: Sergey Kruk <sergey.kruk@gmail.com>
+ *
+ * This file is part of GPhoto4Ruby.
+ *
+ * GPhoto4Ruby is free software: you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation, either
+ * version 3 of the License, or (at your option) any later version.
+ *
+ * GPhoto4Ruby 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 GPhoto4Ruby. If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include "gphoto2camera_event.h"
+
+/*
+ * call-seq:
+ *   type                           =>      string
+ *
+ * Returns type of event. Can be compared to EVENT_TYPE class constants
+ *
+ * Examples:
+ *
+ *   c = GPhoto2::Camera.new
+ *   # capture the image manually
+ *   evt = c.wait
+ *   evt.type                       #=>     "file added"
+ *   evt.type == GPhoto2::CameraEvent::EVENT_TYPE_FILE_ADDED
+ *                                  #=>     true
+ *   evt.file                       #=>     "DSC_0384.JPG"
+ *   
+ *   # do nothing
+ *   c.wait(1).type                 #=>     "timeout"
+ */
+VALUE camera_event_type(VALUE self) {
+    GPhoto2CameraEvent *ce;
+    
+    Data_Get_Struct(self, GPhoto2CameraEvent, ce);
+    
+    switch (ce->type) {
+        case GP_EVENT_FILE_ADDED:
+            return EVENT_FILE_ADDED;
+        case GP_EVENT_FOLDER_ADDED:
+            return EVENT_FOLDER_ADDED;
+        case GP_EVENT_TIMEOUT:
+            return EVENT_TIMEOUT;
+        case GP_EVENT_UNKNOWN:
+            return EVENT_UNKNOWN;
+        default:
+            return Qnil;
+    }
+}
+
+/*
+ * call-seq:
+ *   file                           =>      string or nil
+ *
+ * Returns file name of manually captured image. Only applies to
+ * EVENT_TYPE_FILE_ADDED event.
+ *
+ * Examples:
+ *
+ *   c = GPhoto2::Camera.new
+ *   # capture the image manually
+ *   evt = c.wait
+ *   evt.type                       #=>     "file added"
+ *   evt.type == GPhoto2::CameraEvent::EVENT_TYPE_FILE_ADDED
+ *                                  #=>     true
+ *   evt.file                       #=>     "DSC_0384.JPG"
+ *   
+ *   # do nothing
+ *   c.wait(1).type                 #=>     "timeout"
+ */
+VALUE camera_event_file(VALUE self) {
+    GPhoto2CameraEvent *ce;
+    
+    Data_Get_Struct(self, GPhoto2CameraEvent, ce);
+    
+    if (ce->type == GP_EVENT_FILE_ADDED) {
+        return rb_str_new2(ce->path->name);
+    } else {
+        return Qnil;
+    }
+}
+

data/ext/gphoto2camera_event.h

@@ -0,0 +1,44 @@
+/**
+ *
+ * Copyright 2008 neq4 company <http://neq4.com>
+ * Author: Sergey Kruk <sergey.kruk@gmail.com>
+ *
+ * This file is part of GPhoto4Ruby.
+ *
+ * GPhoto4Ruby is free software: you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation, either
+ * version 3 of the License, or (at your option) any later version.
+ *
+ * GPhoto4Ruby 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 GPhoto4Ruby. If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include <gphoto2/gphoto2.h>
+#include <ruby.h>
+
+#ifndef _INC_CAMERA_EVENT
+#define _INC_CAMERA_EVENT
+
+typedef struct {
+    CameraEventType type;
+    CameraFilePath *path;
+} GPhoto2CameraEvent;
+
+VALUE rb_cGPhoto2CameraEvent;
+
+#define EVENT_UNKNOWN rb_str_new2("unknown")
+#define EVENT_TIMEOUT rb_str_new2("timeout")
+#define EVENT_FILE_ADDED rb_str_new2("file added")
+#define EVENT_FOLDER_ADDED rb_str_new2("folder added")
+
+VALUE camera_event_type(VALUE self);
+VALUE camera_event_file(VALUE self);
+
+#endif /* _INC_CAMERA_EVENT */

data/ext/gphoto2camera_utilities.c

@@ -0,0 +1,234 @@
+/**
+ *
+ * Copyright 2008 neq4 company <http://neq4.com>
+ * Author: Sergey Kruk <sergey.kruk@gmail.com>
+ *
+ * This file is part of GPhoto4Ruby.
+ *
+ * GPhoto4Ruby is free software: you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation, either
+ * version 3 of the License, or (at your option) any later version.
+ *
+ * GPhoto4Ruby 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 GPhoto4Ruby. If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include "gphoto2camera_utilities.h"
+
+void rb_raise_gp_result(int retval) {
+    rb_raise(rb_cGPhoto2Exception, "LibGPhoto2 function returned: %s", gp_result_as_string(retval));
+}
+
+int gp_result_check(int retval) {
+    if (retval < GP_OK) {
+        rb_raise_gp_result(retval);
+    }
+    return retval;
+}
+
+VALUE getRadio(CameraWidget *cc) {
+    const char *val;
+    
+    gp_result_check(gp_widget_get_value(cc, &val));
+    return rb_str_new2(val);
+}
+
+VALUE listRadio(CameraWidget *cc) {
+    int i, choicesTotal;
+    const char *choice;
+    VALUE arr;
+
+    choicesTotal = gp_result_check(gp_widget_count_choices(cc));
+    arr = rb_ary_new();
+    for (i = 0; i < choicesTotal; i++) {
+        gp_result_check(gp_widget_get_choice(cc, i, &choice));
+        rb_ary_push(arr, rb_str_new2(choice));
+    }
+    return arr;
+
+VALUE setRadio(VALUE self, GPhoto2Camera *c, VALUE newVal, int save) {
+    const char *val;
+
+    val = RSTRING(rb_funcall(newVal, rb_intern("to_s"), 0))->ptr;
+
+    gp_result_check(gp_widget_set_value(c->childConfig, val));
+    if (save == 1) {
+        saveConfigs(self, c);
+    }
+    return newVal;
+}
+
+VALUE getText(CameraWidget *cc) {
+    const char *val;
+    
+    gp_result_check(gp_widget_get_value(cc, &val));
+    return rb_str_new2(val);
+}
+
+VALUE setText(VALUE self, GPhoto2Camera *c, VALUE newVal, int save) {
+    const char *val;
+
+    val = RSTRING(rb_funcall(newVal, rb_intern("to_s"), 0))->ptr;
+
+    gp_result_check(gp_widget_set_value(c->childConfig, val));
+    if (save == 1) {
+        saveConfigs(self, c);
+    }
+    return newVal;
+}
+
+VALUE getRange(CameraWidget *cc) {
+    float val;
+    gp_result_check(gp_widget_get_value(cc, &val));
+    return rb_float_new(val);
+}
+
+VALUE listRange(CameraWidget *cc) {
+    float min, max, inc, i;
+    VALUE arr;
+
+    gp_result_check(gp_widget_get_range(cc, &min, &max, &inc));
+    arr = rb_ary_new();
+    if (inc > 0) {
+        for (i = min; i <= max; i = i + inc) {
+            rb_ary_push(arr, rb_float_new(i));
+        }
+    } else {
+        rb_ary_push(arr, rb_float_new(min));
+    }
+    return arr;
+}
+
+VALUE setRange(VALUE self, GPhoto2Camera *c, VALUE newNum, int save) {
+    float val;
+
+    val = NUM2DBL(rb_funcall(newNum, rb_intern("to_f"), 0));
+
+    gp_result_check(gp_widget_set_value(c->childConfig, &val));
+    if (save == 1) {
+        saveConfigs(self, c);
+    }
+    return newNum;
+}
+
+VALUE getToggle(CameraWidget *cc) {
+    int val;
+    gp_result_check(gp_widget_get_value(cc, &val));
+    if (val == 1) {
+        return Qtrue;
+    } else {
+        return Qfalse;
+    }
+}
+
+VALUE setToggle(VALUE self, GPhoto2Camera *c, VALUE newVal, int save) {
+    int val = -1;
+    char *nV;
+    
+    switch(TYPE(newVal)) {
+        case T_TRUE:
+            val = 1;
+            break;
+        case T_FALSE:
+            val = 0;
+            break;
+        case T_SYMBOL:
+            nV = rb_id2name(rb_to_id(newVal));
+            if (strcmp(nV, "true") == 0) {
+                val = 1;
+            } else if(strcmp(nV, "false") == 0) {
+                val = 0;
+            }
+    }
+    
+    if (val >= 0) {
+        gp_result_check(gp_widget_set_value(c->childConfig, &val));
+        if (save == 1) {
+            saveConfigs(self, c);
+        }
+        if (val == 1) {
+            return Qtrue;
+        } else {
+            return Qfalse;
+        }
+    } else {
+        return Qnil;
+    }
+}
+
+void saveConfigs(VALUE self, GPhoto2Camera *c) {
+    VALUE cfgs, cfg_changed, name;
+    CameraWidgetType widgettype;
+    
+    gp_result_check(gp_camera_set_config(c->camera, c->config, c->context));
+    gp_result_check(gp_camera_get_config(c->camera, &(c->config), c->context));
+    cfg_changed = rb_iv_get(self, "@configs_changed");
+    cfgs = rb_iv_get(self, "@configuration");
+    name = rb_ary_shift(cfg_changed);
+    while (TYPE(name) != T_NIL) {
+        gp_result_check(gp_widget_get_child_by_name(c->config, RSTRING(name)->ptr, &(c->childConfig)));
+        gp_result_check(gp_widget_get_type(c->childConfig, &widgettype));
+        switch (widgettype) {
+            case GP_WIDGET_RADIO:
+                rb_hash_aset(cfgs, name, getRadio(c->childConfig));
+                break;
+            case GP_WIDGET_TEXT:
+                rb_hash_aset(cfgs, name, getText(c->childConfig));
+                break;
+            case GP_WIDGET_RANGE:
+                rb_hash_aset(cfgs, name, getRange(c->childConfig));
+                break;
+            case GP_WIDGET_TOGGLE:
+                rb_hash_aset(cfgs, name, getToggle(c->childConfig));
+                break;
+            default:
+                break;
+        }
+        name = rb_ary_shift(cfg_changed);
+    }
+}
+
+void populateWithConfigs(CameraWidget *cc, VALUE hash) {
+    int i, childrenTotal;
+    const char *name;
+    CameraWidget *child;
+    CameraWidgetType widgettype;
+    
+    gp_result_check(gp_widget_get_type(cc, &widgettype));
+    switch (widgettype) {
+        case GP_WIDGET_RADIO:
+            gp_result_check(gp_widget_get_name(cc, &name));
+            rb_hash_aset(hash, rb_str_new2(name), getRadio(cc));
+            break;
+        case GP_WIDGET_TEXT:
+            gp_result_check(gp_widget_get_name(cc, &name));
+            rb_hash_aset(hash, rb_str_new2(name), getText(cc));
+            break;
+        case GP_WIDGET_RANGE:
+            gp_result_check(gp_widget_get_name(cc, &name));
+            rb_hash_aset(hash, rb_str_new2(name), getRange(cc));
+            break;
+        case GP_WIDGET_TOGGLE:
+            gp_result_check(gp_widget_get_name(cc, &name));
+            rb_hash_aset(hash, rb_str_new2(name), getToggle(cc));
+            break;
+        case GP_WIDGET_WINDOW:
+        case GP_WIDGET_SECTION:
+            childrenTotal = gp_result_check(gp_widget_count_children(cc));
+            for (i = 0; i < childrenTotal; i ++) {
+                gp_result_check(gp_widget_get_child(cc, i, &child));
+                populateWithConfigs(child, hash);
+            }
+            break;
+        default:
+            break;
+    }
+}
+

data/ext/gphoto2camera_utilities.h

@@ -0,0 +1,64 @@
+/**
+ *
+ * Copyright 2008 neq4 company <http://neq4.com>
+ * Author: Sergey Kruk <sergey.kruk@gmail.com>
+ *
+ * This file is part of GPhoto4Ruby.
+ *
+ * GPhoto4Ruby is free software: you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation, either
+ * version 3 of the License, or (at your option) any later version.
+ *
+ * GPhoto4Ruby 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 GPhoto4Ruby. If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <gphoto2/gphoto2.h>
+#include <ruby.h>
+
+#ifndef _INC_CAMERA_UTILITIES
+#define _INC_CAMERA_UTILITIES
+
+typedef struct {
+    Camera *camera;
+    CameraWidget *config;
+    CameraWidget *childConfig;
+    CameraList *list;
+    CameraFilePath path;
+    CameraFile *file;
+    GPContext *context;
+    
+    char *virtFolder;
+} GPhoto2Camera;
+
+VALUE rb_cGPhoto2Exception;
+
+void rb_raise_gp_result(int retval);
+int gp_result_check(int retval);
+
+VALUE getRadio(CameraWidget *cc);
+VALUE listRadio(CameraWidget *cc);
+VALUE setRadio(VALUE self, GPhoto2Camera *c, VALUE newVal, int save);
+VALUE getText(CameraWidget *cc);
+VALUE setText(VALUE self, GPhoto2Camera *c, VALUE newVal, int save);
+VALUE getRange(CameraWidget *cc);
+VALUE listRange(CameraWidget *cc);
+VALUE setRange(VALUE self, GPhoto2Camera *c, VALUE newNum, int save);
+VALUE getToggle(CameraWidget *cc);
+VALUE setToggle(VALUE self, GPhoto2Camera *c, VALUE newVal, int save);
+void saveConfigs(VALUE self, GPhoto2Camera *c);
+
+void populateWithConfigs(CameraWidget *cc, VALUE arr);
+
+#endif /* _INC_CAMERA_UTILITIES */
+