More event work.
[ruby-evas.git] / src / rb_evas_object.c
1 /*
2  * $Id: rb_evas_object.c 304 2005-03-22 17:51:51Z 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 #include <stdbool.h>
23
24 #include <Evas.h>
25
26 #define __RB_EVAS_OBJECT_C
27 #include "rb_evas_main.h"
28 #include "rb_evas.h"
29 #include "rb_evas_object.h"
30
31 VALUE cEvasObject;
32
33 VALUE TO_EVAS_OBJECT (Evas_Object *o)
34 {
35         void *obj;
36
37         if (!o)
38                 return Qnil;
39
40         if (!(obj = evas_object_data_get (o, RUBY_EVAS_OBJECT_KEY))) {
41                 rb_raise (rb_eException, "EvasObject Ruby object key missing");
42                 return Qnil;
43         }
44
45         return (VALUE) obj;
46 }
47
48 /* called by the child classes */
49 void c_evas_object_mark (RbEvasObject *e)
50 {
51         rb_gc_mark (e->parent);
52
53         if (!NIL_P (e->callbacks))
54                 rb_gc_mark (e->callbacks);
55
56         if (!NIL_P (e->userdata))
57                 rb_gc_mark (e->userdata);
58 }
59
60 void c_evas_object_free (RbEvasObject *e, bool free_mem)
61 {
62         if (e->real)
63                 evas_object_del (e->real);
64
65         if (free_mem)
66                 free (e);
67 }
68
69 /* :nodoc: */
70 static VALUE c_init (VALUE self, VALUE parent)
71 {
72         GET_OBJ (self, RbEvasObject, e);
73
74         evas_object_data_set (e->real, RUBY_EVAS_OBJECT_KEY, (void *) self);
75
76         e->parent = parent;
77         e->callbacks = Qnil;
78
79         return self;
80 }
81
82 /* :nodoc: */
83 static VALUE c_inspect (VALUE self)
84 {
85         INSPECT (self, RbEvasObject);
86 }
87
88 /*
89  * call-seq:
90  *  e.delete => nil
91  *
92  * Deletes <i>e</i>.
93  */
94 static VALUE c_delete (VALUE self)
95 {
96         GET_OBJ (self, RbEvasObject, e);
97
98         evas_object_del (e->real);
99         e->real = NULL;
100
101         return Qnil;
102 }
103
104 /*
105  * call-seq:
106  *  e.resize(width, height) => nil
107  *
108  * Resizes <i>e</i> to width x height.
109  *
110  *  e.resize(100, 200) #=> nil
111  */
112 static VALUE c_resize (VALUE self, VALUE w, VALUE h)
113 {
114         GET_OBJ (self, RbEvasObject, e);
115
116         Check_Type (w, T_FIXNUM);
117         Check_Type (h, T_FIXNUM);
118
119         evas_object_resize (e->real, (Evas_Coord) FIX2INT (w),
120                             (Evas_Coord) FIX2INT (h));
121
122         return Qnil;
123 }
124
125 /*
126  * call-seq:
127  *  e.move(x, y) => nil
128  *
129  * Moves <i>e</i> to the coordinates specified in
130  * <i>x</i> and <i>y</i>.
131  *
132  *  e.move(100, 200) #=> nil
133  */
134 static VALUE c_move (VALUE self, VALUE x, VALUE y)
135 {
136         GET_OBJ (self, RbEvasObject, e);
137
138         Check_Type (x, T_FIXNUM);
139         Check_Type (y, T_FIXNUM);
140
141         evas_object_move (e->real, (Evas_Coord) FIX2INT (x),
142                           (Evas_Coord) FIX2INT (y));
143
144         return Qnil;
145 }
146
147 /*
148  * call-seq:
149  *  e.geometry => array
150  *
151  * Returns an array containing the geometry of <i>e</i>.
152  *
153  *  e.move(150, 300)   #=> nil
154  *  e.resize(200, 200) #=> nil
155  *  e.geometry         #=> [150, 300, 200, 200]
156  */
157 static VALUE c_geometry_get (VALUE self)
158 {
159         int x = 0, y = 0, w = 0, h = 0;
160
161         GET_OBJ (self, RbEvasObject, e);
162
163         evas_object_geometry_get (e->real,
164                                   (Evas_Coord *) &x, (Evas_Coord *) &y,
165                                   (Evas_Coord *) &w, (Evas_Coord *) &h);
166
167         return rb_ary_new3 (4, INT2FIX (x), INT2FIX (y), INT2FIX (w),
168                             INT2FIX (h));
169 }
170
171 /*
172  * call-seq:
173  *  e.show => nil
174  *
175  * Shows <i>e</i>.
176  */
177 static VALUE c_show (VALUE self)
178 {
179         GET_OBJ (self, RbEvasObject, e);
180
181         evas_object_show (e->real);
182
183         return Qnil;
184 }
185
186 /*
187  * call-seq:
188  *  e.hide => nil
189  *
190  * Hides <i>e</i>.
191  */
192 static VALUE c_hide (VALUE self)
193 {
194         GET_OBJ (self, RbEvasObject, e);
195
196         evas_object_hide (e->real);
197
198         return Qnil;
199 }
200
201 /*
202  * call-seq:
203  *  e.visible? => true or false
204  *
205  * Returns true if <i>e</i> is visible, else returns false.
206  */
207 static VALUE c_visible_get (VALUE self)
208 {
209         GET_OBJ (self, RbEvasObject, e);
210
211         return evas_object_visible_get (e->real) ? Qtrue : Qfalse;
212 }
213
214 /*
215  * call-seq:
216  *  e.evas => evas
217  *
218  * Returns the <code>Evas::Evas</code> for <i>e</i>.
219  */
220 static VALUE c_evas_get (VALUE self)
221 {
222         GET_OBJ (self, RbEvasObject, e);
223
224         return e->parent;
225 }
226
227 /*
228  * call-seq:
229  *  e.name => string
230  *
231  * Returns the name of <i>e</i>.
232  */
233 static VALUE c_name_get (VALUE self)
234 {
235         const char *name;
236
237         GET_OBJ (self, RbEvasObject, e);
238
239         if (!(name = evas_object_name_get (e->real)))
240                 return Qnil;
241         else
242                 return rb_str_new2 (name);
243 }
244
245 /*
246  * call-seq:
247  *  e.name(string)
248  *
249  * Sets the name of <i>e</i>.
250  */
251 static VALUE c_name_set (VALUE self, VALUE val)
252 {
253         GET_OBJ (self, RbEvasObject, e);
254
255         Check_Type (val, T_STRING);
256
257         evas_object_name_set (e->real, StringValuePtr (val));
258
259         return Qnil;
260 }
261
262 /*
263  * call-seq:
264  *  e.layer => fixnum
265  *
266  * Returns the layer <i>e</i> is in.
267  */
268 static VALUE c_layer_get (VALUE self)
269 {
270         GET_OBJ (self, RbEvasObject, e);
271
272         return INT2FIX (evas_object_layer_get (e->real));
273 }
274
275 /*
276  * call-seq:
277  *  e.layer(fixnum)
278  *
279  * Sets the layer <i>e</i> is in.
280  */
281 static VALUE c_layer_set (VALUE self, VALUE val)
282 {
283         GET_OBJ (self, RbEvasObject, e);
284
285         Check_Type (val, T_FIXNUM);
286
287         evas_object_layer_set (e->real, NUM2INT (val));
288
289         return Qnil;
290 }
291
292 /*
293  * call-seq:
294  *  e.get_color => array
295  *
296  * Returns the color of <i>e</i>.
297  *
298  *  e.set_color(128, 128, 128, 0) #=> nil
299  *  e.get_color                   #=> [128, 128, 128, 0]
300  */
301 static VALUE c_get_color (VALUE self)
302 {
303         int r = 0, g = 0, b = 0, a = 0;
304
305         GET_OBJ (self, RbEvasObject, e);
306
307         evas_object_color_get (e->real, &r, &g, &b, &a);
308
309         return rb_ary_new3 (4, INT2FIX (r), INT2FIX (g), INT2FIX (b),
310                             INT2FIX (a));
311 }
312
313 /*
314  * call-seq:
315  *  e.set_color(r, g, b, a) => nil
316  *
317  * Sets the color of <i>e</i>.
318  *
319  *  e.set_color(128, 128, 128, 0) #=> nil
320  */
321 static VALUE c_set_color (VALUE self, VALUE r, VALUE g, VALUE b,
322                           VALUE a)
323 {
324         GET_OBJ (self, RbEvasObject, e);
325
326         Check_Type (r, T_FIXNUM);
327         Check_Type (g, T_FIXNUM);
328         Check_Type (b, T_FIXNUM);
329         Check_Type (a, T_FIXNUM);
330
331         evas_object_color_set (e->real, FIX2INT (r), FIX2INT (g),
332                                FIX2INT (b), FIX2INT (a));
333
334         return Qnil;
335 }
336
337 /*
338  * call-seq:
339  *  e.pass_events? => true or false
340  *
341  * Returns true if <i>e</i> passes events on to EvasObjects that are
342  * below itself, else returns false.
343  */
344 static VALUE c_pass_events_get (VALUE self)
345 {
346         GET_OBJ (self, RbEvasObject, e);
347
348         return evas_object_pass_events_get (e->real) ? Qtrue : Qfalse;
349 }
350
351 /*
352  * call-seq:
353  *  e.pass_events(true or false)
354  *
355  * Sets whether <i>e</i> passes events on to EvasObjects that are
356  * below itself.
357  */
358 static VALUE c_pass_events_set (VALUE self, VALUE val)
359 {
360         GET_OBJ (self, RbEvasObject, e);
361
362         CHECK_BOOL (val);
363
364         evas_object_pass_events_set (e->real, val == Qtrue);
365
366         return Qnil;
367 }
368
369 /*
370  * call-seq:
371  *  e.repeat_events? => true or false
372  *
373  * Returns true if <i>e</i> repeats events to EvasObjects that are
374  * below itself, else returns false.
375  */
376 static VALUE c_repeat_events_get (VALUE self)
377 {
378         GET_OBJ (self, RbEvasObject, e);
379
380         return evas_object_repeat_events_get (e->real) ? Qtrue : Qfalse;
381 }
382
383 /*
384  * call-seq:
385  *  e.repeat_events(true or false)
386  *
387  * Sets whether <i>e</i> repeats events to EvasObjects that are
388  * below itself.
389  */
390 static VALUE c_repeat_events_set (VALUE self, VALUE val)
391 {
392         GET_OBJ (self, RbEvasObject, e);
393
394         CHECK_BOOL (val);
395
396         evas_object_repeat_events_set (e->real, val == Qtrue);
397
398         return Qnil;
399 }
400
401 /*
402  * call-seq:
403  *   e.raise => nil
404  *
405  * Raises <i>e</i>.
406  */
407 static VALUE c_raise (VALUE self)
408 {
409         GET_OBJ (self, RbEvasObject, e);
410
411         evas_object_raise (e->real);
412
413         return Qnil;
414 }
415
416 /*
417  * call-seq:
418  *  e.lower => nil
419  *
420  * Lowers <i>e</i>.
421  */
422 static VALUE c_lower (VALUE self)
423 {
424         GET_OBJ (self, RbEvasObject, e);
425
426         evas_object_lower (e->real);
427
428         return Qnil;
429 }
430
431 /*
432  * call-seq:
433  *  e.stack_above(evasobject) => nil
434  *
435  * Positions <i>e</i> above <i>evasobject</i>.
436  */
437 static VALUE c_stack_above (VALUE self, VALUE target)
438 {
439         GET_OBJ (self, RbEvasObject, e);
440
441         CHECK_CLASS (target, cEvasObject);
442         GET_OBJ (target, RbEvasObject, t);
443
444         evas_object_stack_above (e->real, t->real);
445
446         return Qnil;
447 }
448
449 /*
450  * call-seq:
451  *  e.stack_below(evasobject) => nil
452  *
453  * Positions <i>e</i> below <i>evasobject</i>.
454  */
455 static VALUE c_stack_below (VALUE self, VALUE target)
456 {
457         GET_OBJ (self, RbEvasObject, e);
458
459         CHECK_CLASS (target, cEvasObject);
460         GET_OBJ (target, RbEvasObject, t);
461
462         evas_object_stack_below (e->real, t->real);
463
464         return Qnil;
465 }
466
467 /*
468  * call-seq:
469  *  e.above => evasobject
470  *
471  * Returns the <code>Evas::EvasObject</code> that's positioned above
472  * <i>e</i>.
473  */
474 static VALUE c_above_get (VALUE self)
475 {
476         GET_OBJ (self, RbEvasObject, e);
477
478         return TO_EVAS_OBJECT (evas_object_above_get (e->real));
479 }
480
481 /*
482  * call-seq:
483  *  e.below => evasobject
484  *
485  * Returns the <code>Evas::EvasObject</code> that's positioned below
486  * <i>e</i>.
487  */
488 static VALUE c_below_get (VALUE self)
489 {
490         GET_OBJ (self, RbEvasObject, e);
491
492         return TO_EVAS_OBJECT (evas_object_below_get (e->real));
493 }
494
495 static VALUE c_userdata_get (VALUE self)
496 {
497         GET_OBJ (self, RbEvasObject, e);
498
499         if (NIL_P (e->userdata))
500                 e->userdata = rb_hash_new ();
501
502         return e->userdata;
503 }
504
505 void Init_EvasObject (void)
506 {
507         cEvasObject = rb_define_class_under (mEvas, "EvasObject",
508                                              rb_cObject);
509
510         rb_define_private_method (rb_singleton_class (cEvasObject),
511                                   "new", NULL, 0);
512         rb_define_method (cEvasObject, "initialize", c_init, 1);
513         rb_define_method (cEvasObject, "inspect", c_inspect, 0);
514         rb_define_method (cEvasObject, "delete", c_delete, 0);
515         rb_define_method (cEvasObject, "resize", c_resize, 2);
516         rb_define_method (cEvasObject, "move", c_move, 2);
517         rb_define_method (cEvasObject, "geometry", c_geometry_get, 0);
518         rb_define_method (cEvasObject, "show", c_show, 0);
519         rb_define_method (cEvasObject, "hide", c_hide, 0);
520         rb_define_method (cEvasObject, "visible?", c_visible_get, 0);
521         rb_define_method (cEvasObject, "evas", c_evas_get, 0);
522         rb_define_method (cEvasObject, "name", c_name_get, 0);
523         rb_define_method (cEvasObject, "name=", c_name_set, 1);
524         rb_define_method (cEvasObject, "layer", c_layer_get, 0);
525         rb_define_method (cEvasObject, "layer=", c_layer_set, 1);
526         rb_define_method (cEvasObject, "get_color", c_get_color, 0);
527         rb_define_method (cEvasObject, "set_color", c_set_color, 4);
528         rb_define_method (cEvasObject, "pass_events?",
529                           c_pass_events_get, 0);
530         rb_define_method (cEvasObject, "pass_events=",
531                           c_pass_events_set, 1);
532         rb_define_method (cEvasObject, "repeat_events?",
533                           c_repeat_events_get, 0);
534         rb_define_method (cEvasObject, "repeat_events=",
535                           c_repeat_events_set, 1);
536         rb_define_method (cEvasObject, "raise", c_raise, 0);
537         rb_define_method (cEvasObject, "lower", c_lower, 0);
538         rb_define_method (cEvasObject, "stack_above", c_stack_above, 1);
539         rb_define_method (cEvasObject, "stack_below", c_stack_below, 1);
540         rb_define_method (cEvasObject, "above", c_above_get, 0);
541         rb_define_method (cEvasObject, "below", c_below_get, 0);
542         rb_define_method (cEvasObject, "userdata", c_userdata_get, 0);
543 }