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 }