src/rb_evas_object.c

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