src/rb_edje.c

   1 /*
   2  * $Id: rb_edje.c 51 2004-08-01 10:19:02Z tilman $
   3  *
   4  * Copyright (C) 2004 Tilman Sauerbeck (tilman at code-monkey de)
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  */
  20
  21 #include <ruby.h>
  22
  23 #include <Edje.h>
  24 #include <evas/rb_evas.h>
  25 #include <evas/rb_evas_object.h>
  26
  27 #define __RB_EDJE_C
  28 #include "rb_edje.h"
  29 #include "rb_edje_main.h"
  30 #include "rb_part.h"
  31
  32 VALUE cEdje;
  33
  34 static void c_mark (RbEdje *e)
  35 {
  36         c_evas_object_mark (&e->real);
  37
  38         rb_gc_mark (e->parts);
  39         rb_gc_mark (e->callbacks);
  40
  41         if (!NIL_P (e->on_text_changed_cb))
  42                 rb_gc_mark (e->on_text_changed_cb);
  43 }
  44
  45 static void c_free (RbEdje *e)
  46 {
  47         c_evas_object_free (&e->real, false);
  48
  49         edje_shutdown ();
  50 }
  51
  52 static VALUE c_new (VALUE klass, VALUE evas)
  53 {
  54         VALUE self, argv[1];
  55         RbEdje *edje = NULL;
  56
  57         CHECK_CLASS (evas, cEvas);
  58         GET_OBJ (evas, RbEvas, e);
  59
  60         edje_init ();
  61
  62         self = Data_Make_Struct (klass, RbEdje, c_mark, c_free, edje);
  63
  64         edje->real.real = edje_object_add (e->real);
  65         edje->parts = rb_hash_new ();
  66         edje->callbacks = rb_ary_new ();
  67         edje->on_text_changed_cb = Qnil;
  68
  69         argv[0] = evas;
  70         rb_obj_call_init (self, 1, argv);
  71
  72         return self;
  73 }
  74
  75 static VALUE c_freeze (VALUE self)
  76 {
  77         GET_OBJ (self, RbEdje, e);
  78
  79         edje_object_freeze (e->real.real);
  80
  81         return Qnil;
  82 }
  83
  84 static VALUE c_thaw (VALUE self)
  85 {
  86         GET_OBJ (self, RbEdje, e);
  87
  88         edje_object_thaw (e->real.real);
  89
  90         return Qnil;
  91 }
  92
  93 static VALUE c_load (VALUE self, VALUE eet, VALUE group)
  94 {
  95         GET_OBJ (self, RbEdje, e);
  96
  97         Check_Type (eet, T_STRING);
  98         Check_Type (group, T_STRING);
  99
 100         if (!edje_object_file_set (e->real.real, StringValuePtr (eet),
 101                                    StringValuePtr (group)))
 102                 rb_raise (rb_eException, "Cannot load eet");
 103
 104         return Qnil;
 105 }
 106
 107 static VALUE c_get_size_min (VALUE self)
 108 {
 109         int w = 0, h = 0;
 110
 111         GET_OBJ (self, RbEdje, e);
 112
 113         edje_object_size_min_get (e->real.real, &w, &h);
 114
 115         return rb_ary_new3 (2, INT2FIX (w), INT2FIX (h));
 116 }
 117
 118 static VALUE c_get_size_max (VALUE self)
 119 {
 120         int w = 0, h = 0;
 121
 122         GET_OBJ (self, RbEdje, e);
 123
 124         edje_object_size_max_get (e->real.real, &w, &h);
 125
 126         return rb_ary_new3 (2, INT2FIX (w), INT2FIX (h));
 127 }
 128
 129 static VALUE c_part_exists_get (VALUE self, VALUE name)
 130 {
 131         int r;
 132
 133         GET_OBJ (self, RbEdje, e);
 134
 135         Check_Type (name, T_STRING);
 136
 137         r = edje_object_part_exists (e->real.real, StringValuePtr (name));
 138
 139         return r ? Qtrue : Qfalse;
 140 }
 141
 142 static VALUE c_part_get (VALUE self, VALUE name)
 143 {
 144         VALUE part;
 145
 146         GET_OBJ (self, RbEdje, e);
 147         Check_Type (name, T_STRING);
 148
 149         if (!edje_object_part_exists (e->real.real, StringValuePtr (name)))
 150                 return Qnil;
 151
 152         if (NIL_P (part = rb_hash_aref (e->parts, name))) {
 153                 part = TO_PART (self, name);
 154                 rb_hash_aset (e->parts, name, part);
 155         }
 156
 157         return part;
 158 }
 159
 160 static void on_text_changed (void *data, Evas_Object *eo,
 161                              const char *part_name)
 162 {
 163         VALUE self = (VALUE) data, part, name;
 164
 165         GET_OBJ (self, RbEdje, e);
 166
 167         name = rb_str_new2 (part_name);
 168
 169         if (NIL_P (part = rb_hash_aref (e->parts, name))) {
 170                 part = TO_PART (self, name);
 171                 rb_hash_aset (e->parts, name, part);
 172         }
 173
 174         rb_funcall (e->on_text_changed_cb,
 175                     rb_intern ("call"), 1, part);
 176 }
 177
 178 static VALUE c_on_text_changed (VALUE self)
 179 {
 180         GET_OBJ (self, RbEdje, e);
 181
 182         if (!rb_block_given_p ())
 183                 return Qnil;
 184
 185         e->on_text_changed_cb = rb_block_proc ();
 186
 187         edje_object_text_change_cb_set (e->real.real, on_text_changed,
 188                                         (void *) self);
 189
 190         return Qnil;
 191 }
 192
 193 static VALUE c_emit_signal (VALUE self, VALUE emission, VALUE source)
 194 {
 195         GET_OBJ (self, RbEdje, e);
 196
 197         Check_Type (emission, T_STRING);
 198         Check_Type (source, T_STRING);
 199
 200         edje_object_signal_emit (e->real.real, StringValuePtr (emission),
 201                                  StringValuePtr (source));
 202
 203         return Qnil;
 204 }
 205
 206 static void on_signal (void *data, Evas_Object *o,
 207                        const char *emission, const char *src)
 208 {
 209         rb_funcall ((VALUE) data, rb_intern ("call"), 2,
 210                     rb_str_new2 (emission), rb_str_new2 (src));
 211 }
 212
 213 static VALUE c_on_signal (VALUE self, VALUE signal, VALUE src)
 214 {
 215         VALUE cb;
 216
 217         GET_OBJ (self, RbEdje, e);
 218
 219         Check_Type (signal, T_STRING);
 220         Check_Type (src, T_STRING);
 221
 222         if (!rb_block_given_p ())
 223                 return Qnil;
 224
 225         cb = rb_block_proc ();
 226         rb_ary_push (e->callbacks, cb);
 227
 228         edje_object_signal_callback_add (e->real.real,
 229                                          StringValuePtr (signal),
 230                                          StringValuePtr (src), on_signal,
 231                                          (void *) cb);
 232
 233         return Qnil;
 234 }
 235
 236 static VALUE c_play_get (VALUE self)
 237 {
 238         GET_OBJ (self, RbEdje, e);
 239
 240         return edje_object_play_get (e->real.real) ? Qtrue : Qfalse;
 241 }
 242
 243 static VALUE c_play_set (VALUE self, VALUE val)
 244 {
 245         GET_OBJ (self, RbEdje, e);
 246
 247         CHECK_BOOL(val);
 248
 249         edje_object_play_set (e->real.real, val == Qtrue);
 250
 251         return Qnil;
 252 }
 253
 254 static VALUE c_animation_get (VALUE self)
 255 {
 256         GET_OBJ (self, RbEdje, e);
 257
 258         return edje_object_animation_get (e->real.real) ? Qtrue : Qfalse;
 259 }
 260
 261 static VALUE c_animation_set (VALUE self, VALUE val)
 262 {
 263         GET_OBJ (self, RbEdje, e);
 264
 265         CHECK_BOOL(val);
 266
 267         edje_object_animation_set (e->real.real, val == Qtrue);
 268
 269         return Qnil;
 270 }
 271
 272 void Init_Edje (void)
 273 {
 274         cEdje = rb_define_class_under (mEdje, "Edje", cEvasObject);
 275
 276         rb_define_singleton_method (cEdje, "new", c_new, 1);
 277         rb_define_method (cEdje, "freeze", c_freeze, 0);
 278         rb_define_method (cEdje, "thaw", c_thaw, 0);
 279         rb_define_method (cEdje, "load", c_load, 2);
 280         rb_define_method (cEdje, "get_size_min", c_get_size_min, 0);
 281         rb_define_method (cEdje, "get_size_max", c_get_size_max, 0);
 282         rb_define_method (cEdje, "part_exists?", c_part_exists_get, 1);
 283         rb_define_method (cEdje, "part", c_part_get, 1);
 284         rb_define_method (cEdje, "on_text_changed", c_on_text_changed, 0);
 285         rb_define_method (cEdje, "emit_signal", c_emit_signal, 2);
 286         rb_define_method (cEdje, "on_signal", c_on_signal, 2);
 287         rb_define_method (cEdje, "play?", c_play_get, 0);
 288         rb_define_method (cEdje, "play=", c_play_set, 1);
 289         rb_define_method (cEdje, "animation?", c_animation_get, 0);
 290         rb_define_method (cEdje, "animation=", c_animation_set, 1);
 291 }