src/rb_evas_object.c

   1 /*
   2  * $Id: rb_evas_object.c 350 2006-02-08 21:13:34Z 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 static VALUE c_type_get (VALUE self)
  89 {
  90         const char *s;
  91
  92         GET_OBJ (self, RbEvasObject, e);
  93
  94         s = evas_object_type_get (e->real);
  95
  96         return s ? rb_str_new2 (s) : Qnil;
  97 }
  98
  99 /*
 100  * call-seq:
 101  *  e.delete => nil
 102  *
 103  * Deletes <i>e</i>.
 104  */
 105 static VALUE c_delete (VALUE self)
 106 {
 107         GET_OBJ (self, RbEvasObject, e);
 108
 109         evas_object_del (e->real);
 110         e->real = NULL;
 111
 112         return Qnil;
 113 }
 114
 115 /*
 116  * call-seq:
 117  *  e.resize(width, height) => nil
 118  *
 119  * Resizes <i>e</i> to width x height.
 120  *
 121  *  e.resize(100, 200) #=> nil
 122  */
 123 static VALUE c_resize (VALUE self, VALUE w, VALUE h)
 124 {
 125         GET_OBJ (self, RbEvasObject, e);
 126
 127         Check_Type (w, T_FIXNUM);
 128         Check_Type (h, T_FIXNUM);
 129
 130         evas_object_resize (e->real, (Evas_Coord) FIX2INT (w),
 131                             (Evas_Coord) FIX2INT (h));
 132
 133         return Qnil;
 134 }
 135
 136 /*
 137  * call-seq:
 138  *  e.move(x, y) => nil
 139  *
 140  * Moves <i>e</i> to the coordinates specified in
 141  * <i>x</i> and <i>y</i>.
 142  *
 143  *  e.move(100, 200) #=> nil
 144  */
 145 static VALUE c_move (VALUE self, VALUE x, VALUE y)
 146 {
 147         GET_OBJ (self, RbEvasObject, e);
 148
 149         Check_Type (x, T_FIXNUM);
 150         Check_Type (y, T_FIXNUM);
 151
 152         evas_object_move (e->real, (Evas_Coord) FIX2INT (x),
 153                           (Evas_Coord) FIX2INT (y));
 154
 155         return Qnil;
 156 }
 157
 158 /*
 159  * call-seq:
 160  *  e.geometry => array
 161  *
 162  * Returns an array containing the geometry of <i>e</i>.
 163  *
 164  *  e.move(150, 300)   #=> nil
 165  *  e.resize(200, 200) #=> nil
 166  *  e.geometry         #=> [150, 300, 200, 200]
 167  */
 168 static VALUE c_geometry_get (VALUE self)
 169 {
 170         int x = 0, y = 0, w = 0, h = 0;
 171
 172         GET_OBJ (self, RbEvasObject, e);
 173
 174         evas_object_geometry_get (e->real,
 175                                   (Evas_Coord *) &x, (Evas_Coord *) &y,
 176                                   (Evas_Coord *) &w, (Evas_Coord *) &h);
 177
 178         return rb_ary_new3 (4, INT2FIX (x), INT2FIX (y), INT2FIX (w),
 179                             INT2FIX (h));
 180 }
 181
 182 /*
 183  * call-seq:
 184  *  e.show => nil
 185  *
 186  * Shows <i>e</i>.
 187  */
 188 static VALUE c_show (VALUE self)
 189 {
 190         GET_OBJ (self, RbEvasObject, e);
 191
 192         evas_object_show (e->real);
 193
 194         return Qnil;
 195 }
 196
 197 /*
 198  * call-seq:
 199  *  e.hide => nil
 200  *
 201  * Hides <i>e</i>.
 202  */
 203 static VALUE c_hide (VALUE self)
 204 {
 205         GET_OBJ (self, RbEvasObject, e);
 206
 207         evas_object_hide (e->real);
 208
 209         return Qnil;
 210 }
 211
 212 /*
 213  * call-seq:
 214  *  e.visible? => true or false
 215  *
 216  * Returns true if <i>e</i> is visible, else returns false.
 217  */
 218 static VALUE c_visible_get (VALUE self)
 219 {
 220         GET_OBJ (self, RbEvasObject, e);
 221
 222         return evas_object_visible_get (e->real) ? Qtrue : Qfalse;
 223 }
 224
 225 /*
 226  * call-seq:
 227  *  e.focused? => true or false
 228  *
 229  * Returns true if <i>e</i> is focused, else returns false.
 230  */
 231 static VALUE c_focused_get (VALUE self)
 232 {
 233         GET_OBJ (self, RbEvasObject, e);
 234
 235         return evas_object_focus_get (e->real) ? Qtrue : Qfalse;
 236 }
 237
 238 /*
 239  * call-seq:
 240  *  e.focused(true or false)
 241  *
 242  * (Un)focuses <i>e</i>.
 243  */
 244 static VALUE c_focused_set (VALUE self, VALUE val)
 245 {
 246         GET_OBJ (self, RbEvasObject, e);
 247
 248         CHECK_BOOL (val);
 249
 250         evas_object_focus_set (e->real, val == Qtrue);
 251
 252         return Qnil;
 253 }
 254
 255 /*
 256  * call-seq:
 257  *  e.evas => evas
 258  *
 259  * Returns the <code>Evas::Evas</code> for <i>e</i>.
 260  */
 261 static VALUE c_evas_get (VALUE self)
 262 {
 263         GET_OBJ (self, RbEvasObject, e);
 264
 265         return e->parent;
 266 }
 267
 268 /*
 269  * call-seq:
 270  *  e.name => string
 271  *
 272  * Returns the name of <i>e</i>.
 273  */
 274 static VALUE c_name_get (VALUE self)
 275 {
 276         const char *name;
 277
 278         GET_OBJ (self, RbEvasObject, e);
 279
 280         if (!(name = evas_object_name_get (e->real)))
 281                 return Qnil;
 282         else
 283                 return rb_str_new2 (name);
 284 }
 285
 286 /*
 287  * call-seq:
 288  *  e.name(string)
 289  *
 290  * Sets the name of <i>e</i>.
 291  */
 292 static VALUE c_name_set (VALUE self, VALUE val)
 293 {
 294         GET_OBJ (self, RbEvasObject, e);
 295
 296         Check_Type (val, T_STRING);
 297
 298         evas_object_name_set (e->real, StringValuePtr (val));
 299
 300         return Qnil;
 301 }
 302
 303 /*
 304  * call-seq:
 305  *  e.layer => fixnum
 306  *
 307  * Returns the layer <i>e</i> is in.
 308  */
 309 static VALUE c_layer_get (VALUE self)
 310 {
 311         GET_OBJ (self, RbEvasObject, e);
 312
 313         return INT2FIX (evas_object_layer_get (e->real));
 314 }
 315
 316 /*
 317  * call-seq:
 318  *  e.layer(fixnum)
 319  *
 320  * Sets the layer <i>e</i> is in.
 321  */
 322 static VALUE c_layer_set (VALUE self, VALUE val)
 323 {
 324         GET_OBJ (self, RbEvasObject, e);
 325
 326         Check_Type (val, T_FIXNUM);
 327
 328         evas_object_layer_set (e->real, NUM2INT (val));
 329
 330         return Qnil;
 331 }
 332
 333 /*
 334  * call-seq:
 335  *  e.get_color => array
 336  *
 337  * Returns the color of <i>e</i>.
 338  *
 339  *  e.set_color(128, 128, 128, 0) #=> nil
 340  *  e.get_color                   #=> [128, 128, 128, 0]
 341  */
 342 static VALUE c_get_color (VALUE self)
 343 {
 344         int r = 0, g = 0, b = 0, a = 0;
 345
 346         GET_OBJ (self, RbEvasObject, e);
 347
 348         evas_object_color_get (e->real, &r, &g, &b, &a);
 349
 350         return rb_ary_new3 (4, INT2FIX (r), INT2FIX (g), INT2FIX (b),
 351                             INT2FIX (a));
 352 }
 353
 354 /*
 355  * call-seq:
 356  *  e.set_color(r, g, b, a) => nil
 357  *
 358  * Sets the color of <i>e</i>.
 359  *
 360  *  e.set_color(128, 128, 128, 0) #=> nil
 361  */
 362 static VALUE c_set_color (VALUE self, VALUE r, VALUE g, VALUE b,
 363                           VALUE a)
 364 {
 365         GET_OBJ (self, RbEvasObject, e);
 366
 367         Check_Type (r, T_FIXNUM);
 368         Check_Type (g, T_FIXNUM);
 369         Check_Type (b, T_FIXNUM);
 370         Check_Type (a, T_FIXNUM);
 371
 372         evas_object_color_set (e->real, FIX2INT (r), FIX2INT (g),
 373                                FIX2INT (b), FIX2INT (a));
 374
 375         return Qnil;
 376 }
 377
 378 static VALUE c_get_clip (VALUE self)
 379 {
 380         GET_OBJ (self, RbEvasObject, e);
 381
 382         return TO_EVAS_OBJECT (evas_object_clip_get (e->real));
 383 }
 384
 385 static VALUE c_set_clip (VALUE self, VALUE clip)
 386 {
 387         GET_OBJ (self, RbEvasObject, e);
 388         GET_OBJ (clip, RbEvasObject, e2);
 389
 390         evas_object_clip_set (e->real, e2->real);
 391
 392         return Qnil;
 393 }
 394
 395 /*
 396  * call-seq:
 397  *  e.pass_events? => true or false
 398  *
 399  * Returns true if <i>e</i> passes events on to EvasObjects that are
 400  * below itself, else returns false.
 401  */
 402 static VALUE c_pass_events_get (VALUE self)
 403 {
 404         GET_OBJ (self, RbEvasObject, e);
 405
 406         return evas_object_pass_events_get (e->real) ? Qtrue : Qfalse;
 407 }
 408
 409 /*
 410  * call-seq:
 411  *  e.pass_events(true or false)
 412  *
 413  * Sets whether <i>e</i> passes events on to EvasObjects that are
 414  * below itself.
 415  */
 416 static VALUE c_pass_events_set (VALUE self, VALUE val)
 417 {
 418         GET_OBJ (self, RbEvasObject, e);
 419
 420         CHECK_BOOL (val);
 421
 422         evas_object_pass_events_set (e->real, val == Qtrue);
 423
 424         return Qnil;
 425 }
 426
 427 /*
 428  * call-seq:
 429  *  e.repeat_events? => true or false
 430  *
 431  * Returns true if <i>e</i> repeats events to EvasObjects that are
 432  * below itself, else returns false.
 433  */
 434 static VALUE c_repeat_events_get (VALUE self)
 435 {
 436         GET_OBJ (self, RbEvasObject, e);
 437
 438         return evas_object_repeat_events_get (e->real) ? Qtrue : Qfalse;
 439 }
 440
 441 /*
 442  * call-seq:
 443  *  e.repeat_events(true or false)
 444  *
 445  * Sets whether <i>e</i> repeats events to EvasObjects that are
 446  * below itself.
 447  */
 448 static VALUE c_repeat_events_set (VALUE self, VALUE val)
 449 {
 450         GET_OBJ (self, RbEvasObject, e);
 451
 452         CHECK_BOOL (val);
 453
 454         evas_object_repeat_events_set (e->real, val == Qtrue);
 455
 456         return Qnil;
 457 }
 458
 459 /*
 460  * call-seq:
 461  *   e.raise => nil
 462  *
 463  * Raises <i>e</i>.
 464  */
 465 static VALUE c_raise (VALUE self)
 466 {
 467         GET_OBJ (self, RbEvasObject, e);
 468
 469         evas_object_raise (e->real);
 470
 471         return Qnil;
 472 }
 473
 474 /*
 475  * call-seq:
 476  *  e.lower => nil
 477  *
 478  * Lowers <i>e</i>.
 479  */
 480 static VALUE c_lower (VALUE self)
 481 {
 482         GET_OBJ (self, RbEvasObject, e);
 483
 484         evas_object_lower (e->real);
 485
 486         return Qnil;
 487 }
 488
 489 /*
 490  * call-seq:
 491  *  e.stack_above(evasobject) => nil
 492  *
 493  * Positions <i>e</i> above <i>evasobject</i>.
 494  */
 495 static VALUE c_stack_above (VALUE self, VALUE target)
 496 {
 497         GET_OBJ (self, RbEvasObject, e);
 498
 499         CHECK_CLASS (target, cEvasObject);
 500         GET_OBJ (target, RbEvasObject, t);
 501
 502         evas_object_stack_above (e->real, t->real);
 503
 504         return Qnil;
 505 }
 506
 507 /*
 508  * call-seq:
 509  *  e.stack_below(evasobject) => nil
 510  *
 511  * Positions <i>e</i> below <i>evasobject</i>.
 512  */
 513 static VALUE c_stack_below (VALUE self, VALUE target)
 514 {
 515         GET_OBJ (self, RbEvasObject, e);
 516
 517         CHECK_CLASS (target, cEvasObject);
 518         GET_OBJ (target, RbEvasObject, t);
 519
 520         evas_object_stack_below (e->real, t->real);
 521
 522         return Qnil;
 523 }
 524
 525 /*
 526  * call-seq:
 527  *  e.above => evasobject
 528  *
 529  * Returns the <code>Evas::EvasObject</code> that's positioned above
 530  * <i>e</i>.
 531  */
 532 static VALUE c_above_get (VALUE self)
 533 {
 534         GET_OBJ (self, RbEvasObject, e);
 535
 536         return TO_EVAS_OBJECT (evas_object_above_get (e->real));
 537 }
 538
 539 /*
 540  * call-seq:
 541  *  e.below => evasobject
 542  *
 543  * Returns the <code>Evas::EvasObject</code> that's positioned below
 544  * <i>e</i>.
 545  */
 546 static VALUE c_below_get (VALUE self)
 547 {
 548         GET_OBJ (self, RbEvasObject, e);
 549
 550         return TO_EVAS_OBJECT (evas_object_below_get (e->real));
 551 }
 552
 553 static VALUE c_userdata_get (VALUE self)
 554 {
 555         GET_OBJ (self, RbEvasObject, e);
 556
 557         if (NIL_P (e->userdata))
 558                 e->userdata = rb_hash_new ();
 559
 560         return e->userdata;
 561 }
 562
 563 void Init_EvasObject (void)
 564 {
 565         cEvasObject = rb_define_class_under (mEvas, "EvasObject",
 566                                              rb_cObject);
 567
 568         rb_define_private_method (rb_singleton_class (cEvasObject),
 569                                   "new", NULL, 0);
 570         rb_define_method (cEvasObject, "initialize", c_init, 1);
 571         rb_define_method (cEvasObject, "inspect", c_inspect, 0);
 572         rb_define_method (cEvasObject, "type", c_type_get, 0);
 573         rb_define_method (cEvasObject, "delete", c_delete, 0);
 574         rb_define_method (cEvasObject, "resize", c_resize, 2);
 575         rb_define_method (cEvasObject, "move", c_move, 2);
 576         rb_define_method (cEvasObject, "geometry", c_geometry_get, 0);
 577         rb_define_method (cEvasObject, "show", c_show, 0);
 578         rb_define_method (cEvasObject, "hide", c_hide, 0);
 579         rb_define_method (cEvasObject, "visible?", c_visible_get, 0);
 580         rb_define_method (cEvasObject, "focused?", c_focused_get, 0);
 581         rb_define_method (cEvasObject, "focused=", c_focused_set, 1);
 582         rb_define_method (cEvasObject, "evas", c_evas_get, 0);
 583         rb_define_method (cEvasObject, "name", c_name_get, 0);
 584         rb_define_method (cEvasObject, "name=", c_name_set, 1);
 585         rb_define_method (cEvasObject, "layer", c_layer_get, 0);
 586         rb_define_method (cEvasObject, "layer=", c_layer_set, 1);
 587         rb_define_method (cEvasObject, "get_color", c_get_color, 0);
 588         rb_define_method (cEvasObject, "set_color", c_set_color, 4);
 589         rb_define_method (cEvasObject, "clip", c_get_clip, 0);
 590         rb_define_method (cEvasObject, "clip=", c_set_clip, 1);
 591         rb_define_method (cEvasObject, "pass_events?",
 592                           c_pass_events_get, 0);
 593         rb_define_method (cEvasObject, "pass_events=",
 594                           c_pass_events_set, 1);
 595         rb_define_method (cEvasObject, "repeat_events?",
 596                           c_repeat_events_get, 0);
 597         rb_define_method (cEvasObject, "repeat_events=",
 598                           c_repeat_events_set, 1);
 599         rb_define_method (cEvasObject, "raise", c_raise, 0);
 600         rb_define_method (cEvasObject, "lower", c_lower, 0);
 601         rb_define_method (cEvasObject, "stack_above", c_stack_above, 1);
 602         rb_define_method (cEvasObject, "stack_below", c_stack_below, 1);
 603         rb_define_method (cEvasObject, "above", c_above_get, 0);
 604         rb_define_method (cEvasObject, "below", c_below_get, 0);
 605         rb_define_method (cEvasObject, "userdata", c_userdata_get, 0);
 606 }