reflexion 0.1.10 → 0.1.11

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (54) hide show
  1. checksums.yaml +4 -4
  2. data/.doc/ext/reflex/body.cpp +53 -0
  3. data/.doc/ext/reflex/native.cpp +0 -4
  4. data/.doc/ext/reflex/selector.cpp +3 -3
  5. data/.doc/ext/reflex/style.cpp +390 -30
  6. data/.doc/ext/reflex/style_length.cpp +1 -1
  7. data/.doc/ext/reflex/view.cpp +24 -6
  8. data/VERSION +1 -1
  9. data/ext/reflex/body.cpp +59 -0
  10. data/ext/reflex/native.cpp +0 -4
  11. data/ext/reflex/selector.cpp +3 -3
  12. data/ext/reflex/style.cpp +432 -32
  13. data/ext/reflex/style_length.cpp +1 -1
  14. data/ext/reflex/view.cpp +25 -5
  15. data/include/reflex/body.h +16 -0
  16. data/include/reflex/ruby.h +5 -3
  17. data/include/reflex/ruby/style.h +11 -0
  18. data/include/reflex/selector.h +7 -1
  19. data/include/reflex/style.h +93 -27
  20. data/include/reflex/view.h +8 -4
  21. data/lib/reflex.rb +0 -2
  22. data/lib/reflex/body.rb +1 -0
  23. data/lib/reflex/button.rb +1 -0
  24. data/lib/reflex/selector.rb +10 -1
  25. data/lib/reflex/style.rb +15 -0
  26. data/lib/reflex/style_length.rb +1 -1
  27. data/lib/reflex/view.rb +5 -2
  28. data/lib/reflex/window.rb +2 -2
  29. data/samples/reflexion/breakout.rb +4 -9
  30. data/src/body.cpp +61 -0
  31. data/src/ios/event.mm +1 -3
  32. data/src/ios/native_window.mm +3 -20
  33. data/src/ios/opengl_view.mm +1 -1
  34. data/src/ios/window.mm +7 -0
  35. data/src/selector.cpp +38 -16
  36. data/src/style.cpp +515 -161
  37. data/src/view.cpp +371 -242
  38. data/src/world.cpp +8 -0
  39. data/test/test_selector.rb +14 -12
  40. data/test/test_style.rb +11 -6
  41. data/test/test_style_length.rb +5 -6
  42. data/test/test_view.rb +8 -7
  43. metadata +2 -17
  44. data/.doc/ext/reflex/style_length2.cpp +0 -149
  45. data/.doc/ext/reflex/style_length4.cpp +0 -192
  46. data/ext/reflex/style_length2.cpp +0 -157
  47. data/ext/reflex/style_length4.cpp +0 -204
  48. data/include/reflex/ruby/style_length.h +0 -63
  49. data/include/reflex/style_length.h +0 -147
  50. data/lib/reflex/style_length2.rb +0 -34
  51. data/lib/reflex/style_length4.rb +0 -38
  52. data/src/style_length.cpp +0 -341
  53. data/test/test_style_length2.rb +0 -50
  54. data/test/test_style_length4.rb +0 -56
checksums.yaml CHANGED
@@ -1,7 +1,7 @@
1
1
  ---
2
2
  SHA1:
3
- metadata.gz: 2bbd862d88e6ae5162205e9b1656a23ce6f62a70
4
- data.tar.gz: 48e9ec4d9ee31e1edc662d7fe7e17e134a2024af
3
+ metadata.gz: bdaed8fe443916ffe6273ee2ae4938dd97afe3a5
4
+ data.tar.gz: b9eeb656bae9a1f91089fccc1c4a31adc892a1fb
5
5
  SHA512:
6
- metadata.gz: 5b8d6a218d4844bcda3f1faa9c6319c9708de00950e9d485e889ab43b184391ae4b13ead28b298942479de9f06c1a8c7c7d7cf9ec3b784a1ab51299a824024de
7
- data.tar.gz: fe2306dac1b6d79b2e73848948392e82ad4ab9e65de34d50a6f0c38dcd597b2236dc8992b3a55d3e7e062f48c9f7cc483f1b87d9e9ce30ec9defb212dd8a30ae
6
+ metadata.gz: a3fc6b52f80e75dc7d4e43cb72de7c02af376da86264da9f279b7c23e8979bf98a1ebd62d684e6607e96e734d102bd1249887109d879f29ad79e49b81373cece
7
+ data.tar.gz: e3e178432bb7fb6dfca698e8d18038f70f1bc4821042598274973971449e6558a442906f37625164b2214e1996bf0b8b080e4856503bf5bdce0a5ee7fc69a663
@@ -140,6 +140,38 @@ VALUE get_angular_velocity(VALUE self)
140
140
  return value(THIS->angular_velocity());
141
141
  }
142
142
 
143
+ static
144
+ VALUE apply_force(VALUE self, VALUE force)
145
+ {
146
+ CHECK;
147
+ THIS->apply_force(to<Rays::Point&>(force));
148
+ return self;
149
+ }
150
+
151
+ static
152
+ VALUE apply_torque(VALUE self, VALUE torque)
153
+ {
154
+ CHECK;
155
+ THIS->apply_torque(torque.as_f(true));
156
+ return self;
157
+ }
158
+
159
+ static
160
+ VALUE apply_linear_impulse(VALUE self, VALUE impulse)
161
+ {
162
+ CHECK;
163
+ THIS->apply_linear_impulse(to<Rays::Point&>(impulse));
164
+ return self;
165
+ }
166
+
167
+ static
168
+ VALUE apply_angular_impulse(VALUE self, VALUE impulse)
169
+ {
170
+ CHECK;
171
+ THIS->apply_angular_impulse(impulse.as_f(true));
172
+ return self;
173
+ }
174
+
143
175
  static
144
176
  VALUE set_density(VALUE self, VALUE density)
145
177
  {
@@ -185,6 +217,21 @@ VALUE get_restitution(VALUE self)
185
217
  return value(THIS->restitution());
186
218
  }
187
219
 
220
+ static
221
+ VALUE set_gravity_scale(VALUE self, VALUE scale)
222
+ {
223
+ CHECK;
224
+ THIS->set_gravity_scale(scale.as_f(true));
225
+ return self;
226
+ }
227
+
228
+ static
229
+ VALUE get_gravity_scale(VALUE self)
230
+ {
231
+ CHECK;
232
+ return value(THIS->gravity_scale());
233
+ }
234
+
188
235
  static
189
236
  VALUE each(VALUE self)
190
237
  {
@@ -222,12 +269,18 @@ Init_body ()
222
269
  rb_define_method(cBody, "linear_velocity", RUBY_METHOD_FUNC(get_linear_velocity), 0);
223
270
  rb_define_method(cBody, "angular_velocity=", RUBY_METHOD_FUNC(set_angular_velocity), 1);
224
271
  rb_define_method(cBody, "angular_velocity", RUBY_METHOD_FUNC(get_angular_velocity), 0);
272
+ rb_define_method(cBody, "apply_force", RUBY_METHOD_FUNC(apply_force), 1);
273
+ rb_define_method(cBody, "apply_torque", RUBY_METHOD_FUNC(apply_torque), 1);
274
+ rb_define_method(cBody, "apply_linear_impulse", RUBY_METHOD_FUNC(apply_linear_impulse), 1);
275
+ rb_define_method(cBody, "apply_angular_impulse", RUBY_METHOD_FUNC(apply_angular_impulse), 1);
225
276
  rb_define_method(cBody, "density=", RUBY_METHOD_FUNC(set_density), 1);
226
277
  rb_define_method(cBody, "density", RUBY_METHOD_FUNC(get_density), 0);
227
278
  rb_define_method(cBody, "friction=", RUBY_METHOD_FUNC(set_friction), 1);
228
279
  rb_define_method(cBody, "friction", RUBY_METHOD_FUNC(get_friction), 0);
229
280
  rb_define_method(cBody, "restitution=", RUBY_METHOD_FUNC(set_restitution), 1);
230
281
  rb_define_method(cBody, "restitution", RUBY_METHOD_FUNC(get_restitution), 0);
282
+ rb_define_method(cBody, "gravity_scale=", RUBY_METHOD_FUNC(set_gravity_scale), 1);
283
+ rb_define_method(cBody, "gravity_scale", RUBY_METHOD_FUNC(get_gravity_scale), 0);
231
284
  rb_define_method(cBody, "each", RUBY_METHOD_FUNC(each), 0);
232
285
  }
233
286
 
@@ -10,8 +10,6 @@ void Init_reflex ();
10
10
  void Init_selector ();
11
11
  void Init_style ();
12
12
  void Init_style_length ();
13
- void Init_style_length2 ();
14
- void Init_style_length4 ();
15
13
 
16
14
  void Init_event ();
17
15
  void Init_update_event ();
@@ -56,8 +54,6 @@ extern "C" void
56
54
  Init_selector();
57
55
  Init_style();
58
56
  Init_style_length();
59
- Init_style_length2();
60
- Init_style_length4();
61
57
 
62
58
  Init_event();
63
59
  Init_update_event();
@@ -70,10 +70,10 @@ VALUE each_tag(VALUE self)
70
70
  }
71
71
 
72
72
  static
73
- VALUE match(VALUE self, VALUE selector)
73
+ VALUE contains(VALUE self, VALUE selector)
74
74
  {
75
75
  CHECK;
76
- return value(THIS->match(to<Reflex::Selector&>(selector)));
76
+ return value(THIS->contains(to<Reflex::Selector&>(selector)));
77
77
  }
78
78
 
79
79
  static
@@ -99,7 +99,7 @@ Init_selector ()
99
99
  rb_define_method(cSelector, "add_tag", RUBY_METHOD_FUNC(add_tag), 1);
100
100
  rb_define_method(cSelector, "remove_tag", RUBY_METHOD_FUNC(remove_tag), 1);
101
101
  rb_define_method(cSelector, "each_tag", RUBY_METHOD_FUNC(each_tag), 0);
102
- rb_define_method(cSelector, "match", RUBY_METHOD_FUNC(match), 1);
102
+ rb_define_method(cSelector, "contains", RUBY_METHOD_FUNC(contains), 1);
103
103
  cSelector.define_method("==", equal);
104
104
  }
105
105
 
@@ -5,7 +5,6 @@
5
5
  #include "rays/ruby/color.h"
6
6
  #include "rays/ruby/image.h"
7
7
  #include "reflex/ruby/selector.h"
8
- #include "reflex/ruby/style_length.h"
9
8
  #include "defs.h"
10
9
 
11
10
 
@@ -94,7 +93,7 @@ VALUE set_flow(VALUE self)
94
93
  check_arg_count(__FILE__, __LINE__, "Style#set_flow", argc, 1, 2);
95
94
 
96
95
  THIS->set_flow(
97
- argc >= 1 ? (Reflex::Style::Flow) argv[0].as_i() : Reflex::Style::FLOW_DOWN,
96
+ (Reflex::Style::Flow) argv[0].as_i(),
98
97
  argc >= 2 ? (Reflex::Style::Flow) argv[1].as_i() : Reflex::Style::FLOW_NONE);
99
98
  }
100
99
 
@@ -108,87 +107,398 @@ VALUE get_flow(VALUE self)
108
107
  }
109
108
 
110
109
  static
111
- VALUE set_size(VALUE self, VALUE size)
110
+ VALUE set_width(VALUE self, VALUE width)
112
111
  {
113
112
  CHECK;
114
- THIS->set_size(to<Reflex::StyleLength2>(size));
113
+ THIS->set_width(to<Reflex::StyleLength>(width));
114
+ }
115
+
116
+ static
117
+ VALUE get_width(VALUE self)
118
+ {
119
+ CHECK;
120
+ return value(THIS->width());
121
+ }
122
+
123
+ static
124
+ VALUE set_height(VALUE self, VALUE height)
125
+ {
126
+ CHECK;
127
+ THIS->set_height(to<Reflex::StyleLength>(height));
128
+ }
129
+
130
+ static
131
+ VALUE get_height(VALUE self)
132
+ {
133
+ CHECK;
134
+ return value(THIS->height());
135
+ }
136
+
137
+ static
138
+ VALUE set_size(VALUE self)
139
+ {
140
+ CHECK;
141
+ check_arg_count(__FILE__, __LINE__, "Style#set_size", argc, 1, 2);
142
+
143
+ set_width (self, argv[0]);
144
+ set_height(self, argc >= 2 ? argv[1] : argv[0]);
115
145
  }
116
146
 
117
147
  static
118
148
  VALUE get_size(VALUE self)
119
149
  {
120
150
  CHECK;
121
- return value(THIS->size());
151
+ return array(get_width(self), get_height(self));
122
152
  }
123
153
 
124
154
  static
125
- VALUE set_position(VALUE self, VALUE position)
155
+ VALUE set_left(VALUE self, VALUE left)
126
156
  {
127
157
  CHECK;
128
- THIS->set_position(to<Reflex::StyleLength4>(position));
158
+ THIS->set_left(to<Reflex::StyleLength>(left));
159
+ }
160
+
161
+ static
162
+ VALUE get_left(VALUE self)
163
+ {
164
+ CHECK;
165
+ return value(THIS->left());
166
+ }
167
+
168
+ static
169
+ VALUE set_top(VALUE self, VALUE top)
170
+ {
171
+ CHECK;
172
+ THIS->set_top(to<Reflex::StyleLength>(top));
173
+ }
174
+
175
+ static
176
+ VALUE get_top(VALUE self)
177
+ {
178
+ CHECK;
179
+ return value(THIS->top());
180
+ }
181
+
182
+ static
183
+ VALUE set_right(VALUE self, VALUE right)
184
+ {
185
+ CHECK;
186
+ THIS->set_right(to<Reflex::StyleLength>(right));
187
+ }
188
+
189
+ static
190
+ VALUE get_right(VALUE self)
191
+ {
192
+ CHECK;
193
+ return value(THIS->right());
194
+ }
195
+
196
+ static
197
+ VALUE set_bottom(VALUE self, VALUE bottom)
198
+ {
199
+ CHECK;
200
+ THIS->set_bottom(to<Reflex::StyleLength>(bottom));
201
+ }
202
+
203
+ static
204
+ VALUE get_bottom(VALUE self)
205
+ {
206
+ CHECK;
207
+ return value(THIS->bottom());
208
+ }
209
+
210
+ static
211
+ VALUE set_position(VALUE self, VALUE left, VALUE top, VALUE right, VALUE bottom)
212
+ {
213
+ CHECK;
214
+ set_left (self, left);
215
+ set_top (self, top);
216
+ set_right (self, right);
217
+ set_bottom(self, bottom);
129
218
  }
130
219
 
131
220
  static
132
221
  VALUE get_position(VALUE self)
133
222
  {
134
223
  CHECK;
135
- return value(THIS->position());
224
+ return array(
225
+ get_left(self),
226
+ get_top(self),
227
+ get_right(self),
228
+ get_bottom(self));
229
+ }
230
+
231
+ static
232
+ VALUE set_offset_left(VALUE self, VALUE left)
233
+ {
234
+ CHECK;
235
+ THIS->set_offset_left(to<Reflex::StyleLength>(left));
236
+ }
237
+
238
+ static
239
+ VALUE get_offset_left(VALUE self)
240
+ {
241
+ CHECK;
242
+ return value(THIS->offset_left());
243
+ }
244
+
245
+ static
246
+ VALUE set_offset_top(VALUE self, VALUE top)
247
+ {
248
+ CHECK;
249
+ THIS->set_offset_top(to<Reflex::StyleLength>(top));
250
+ }
251
+
252
+ static
253
+ VALUE get_offset_top(VALUE self)
254
+ {
255
+ CHECK;
256
+ return value(THIS->offset_top());
257
+ }
258
+
259
+ static
260
+ VALUE set_offset_right(VALUE self, VALUE right)
261
+ {
262
+ CHECK;
263
+ THIS->set_offset_right(to<Reflex::StyleLength>(right));
264
+ }
265
+
266
+ static
267
+ VALUE get_offset_right(VALUE self)
268
+ {
269
+ CHECK;
270
+ return value(THIS->offset_right());
271
+ }
272
+
273
+ static
274
+ VALUE set_offset_bottom(VALUE self, VALUE bottom)
275
+ {
276
+ CHECK;
277
+ THIS->set_offset_bottom(to<Reflex::StyleLength>(bottom));
278
+ }
279
+
280
+ static
281
+ VALUE get_offset_bottom(VALUE self)
282
+ {
283
+ CHECK;
284
+ return value(THIS->offset_bottom());
285
+ }
286
+
287
+ static
288
+ VALUE set_offset(VALUE self, VALUE left, VALUE top, VALUE right, VALUE bottom)
289
+ {
290
+ CHECK;
291
+ set_offset_left (self, left);
292
+ set_offset_top (self, top);
293
+ set_offset_right (self, right);
294
+ set_offset_bottom(self, bottom);
295
+ }
296
+
297
+ static
298
+ VALUE get_offset(VALUE self)
299
+ {
300
+ CHECK;
301
+ return array(
302
+ get_offset_left(self),
303
+ get_offset_top(self),
304
+ get_offset_right(self),
305
+ get_offset_bottom(self));
306
+ }
307
+
308
+ static
309
+ VALUE set_margin_left(VALUE self, VALUE left)
310
+ {
311
+ CHECK;
312
+ THIS->set_margin_left(to<Reflex::StyleLength>(left));
136
313
  }
137
314
 
138
315
  static
139
- VALUE set_margin(VALUE self, VALUE margin)
316
+ VALUE get_margin_left(VALUE self)
140
317
  {
141
318
  CHECK;
142
- THIS->set_margin(to<Reflex::StyleLength4>(margin));
319
+ return value(THIS->margin_left());
320
+ }
321
+
322
+ static
323
+ VALUE set_margin_top(VALUE self, VALUE top)
324
+ {
325
+ CHECK;
326
+ THIS->set_margin_top(to<Reflex::StyleLength>(top));
327
+ }
328
+
329
+ static
330
+ VALUE get_margin_top(VALUE self)
331
+ {
332
+ CHECK;
333
+ return value(THIS->margin_top());
334
+ }
335
+
336
+ static
337
+ VALUE set_margin_right(VALUE self, VALUE right)
338
+ {
339
+ CHECK;
340
+ THIS->set_margin_right(to<Reflex::StyleLength>(right));
341
+ }
342
+
343
+ static
344
+ VALUE get_margin_right(VALUE self)
345
+ {
346
+ CHECK;
347
+ return value(THIS->margin_right());
348
+ }
349
+
350
+ static
351
+ VALUE set_margin_bottom(VALUE self, VALUE bottom)
352
+ {
353
+ CHECK;
354
+ THIS->set_margin_bottom(to<Reflex::StyleLength>(bottom));
355
+ }
356
+
357
+ static
358
+ VALUE get_margin_bottom(VALUE self)
359
+ {
360
+ CHECK;
361
+ return value(THIS->margin_bottom());
362
+ }
363
+
364
+ static
365
+ VALUE set_margin(VALUE self, VALUE left, VALUE top, VALUE right, VALUE bottom)
366
+ {
367
+ CHECK;
368
+ set_margin_left (self, left);
369
+ set_margin_top (self, top);
370
+ set_margin_right (self, right);
371
+ set_margin_bottom(self, bottom);
143
372
  }
144
373
 
145
374
  static
146
375
  VALUE get_margin(VALUE self)
147
376
  {
148
377
  CHECK;
149
- return value(THIS->margin());
378
+ return array(
379
+ get_margin_left(self),
380
+ get_margin_top(self),
381
+ get_margin_right(self),
382
+ get_margin_bottom(self));
150
383
  }
151
384
 
152
385
  static
153
- VALUE set_padding(VALUE self, VALUE padding)
386
+ VALUE set_padding_left(VALUE self, VALUE left)
154
387
  {
155
388
  CHECK;
156
- THIS->set_padding(to<Reflex::StyleLength4>(padding));
389
+ THIS->set_padding_left(to<Reflex::StyleLength>(left));
390
+ }
391
+
392
+ static
393
+ VALUE get_padding_left(VALUE self)
394
+ {
395
+ CHECK;
396
+ return value(THIS->padding_left());
397
+ }
398
+
399
+ static
400
+ VALUE set_padding_top(VALUE self, VALUE top)
401
+ {
402
+ CHECK;
403
+ THIS->set_padding_top(to<Reflex::StyleLength>(top));
404
+ }
405
+
406
+ static
407
+ VALUE get_padding_top(VALUE self)
408
+ {
409
+ CHECK;
410
+ return value(THIS->padding_top());
411
+ }
412
+
413
+ static
414
+ VALUE set_padding_right(VALUE self, VALUE right)
415
+ {
416
+ CHECK;
417
+ THIS->set_padding_right(to<Reflex::StyleLength>(right));
418
+ }
419
+
420
+ static
421
+ VALUE get_padding_right(VALUE self)
422
+ {
423
+ CHECK;
424
+ return value(THIS->padding_right());
425
+ }
426
+
427
+ static
428
+ VALUE set_padding_bottom(VALUE self, VALUE bottom)
429
+ {
430
+ CHECK;
431
+ THIS->set_padding_bottom(to<Reflex::StyleLength>(bottom));
432
+ }
433
+
434
+ static
435
+ VALUE get_padding_bottom(VALUE self)
436
+ {
437
+ CHECK;
438
+ return value(THIS->padding_bottom());
439
+ }
440
+
441
+ static
442
+ VALUE set_padding(VALUE self, VALUE left, VALUE top, VALUE right, VALUE bottom)
443
+ {
444
+ CHECK;
445
+ set_padding_left (self, left);
446
+ set_padding_top (self, top);
447
+ set_padding_right (self, right);
448
+ set_padding_bottom(self, bottom);
157
449
  }
158
450
 
159
451
  static
160
452
  VALUE get_padding(VALUE self)
161
453
  {
162
454
  CHECK;
163
- return value(THIS->padding());
455
+ return array(
456
+ get_padding_left(self),
457
+ get_padding_top(self),
458
+ get_padding_right(self),
459
+ get_padding_bottom(self));
460
+ }
461
+
462
+ static
463
+ VALUE set_fill(VALUE self, VALUE color)
464
+ {
465
+ CHECK;
466
+ THIS->set_fill(to<Reflex::Color&>(color));
467
+ }
468
+
469
+ static
470
+ VALUE get_fill(VALUE self)
471
+ {
472
+ CHECK;
473
+ return value(THIS->fill());
164
474
  }
165
475
 
166
476
  static
167
- VALUE set_background_color(VALUE self, VALUE color)
477
+ VALUE set_stroke(VALUE self, VALUE color)
168
478
  {
169
479
  CHECK;
170
- THIS->set_background_color(to<Reflex::Color&>(color));
480
+ THIS->set_stroke(to<Reflex::Color&>(color));
171
481
  }
172
482
 
173
483
  static
174
- VALUE get_background_color(VALUE self)
484
+ VALUE get_stroke(VALUE self)
175
485
  {
176
486
  CHECK;
177
- return value(THIS->background_color());
487
+ return value(THIS->stroke());
178
488
  }
179
489
 
180
490
  static
181
- VALUE set_background_image(VALUE self, VALUE image)
491
+ VALUE set_image(VALUE self, VALUE image)
182
492
  {
183
493
  CHECK;
184
- THIS->set_background_image(to<Reflex::Image&>(image));
494
+ THIS->set_image(to<Reflex::Image&>(image));
185
495
  }
186
496
 
187
497
  static
188
- VALUE get_background_image(VALUE self)
498
+ VALUE get_image(VALUE self)
189
499
  {
190
500
  CHECK;
191
- return THIS->background_image() ? value(THIS->background_image()) : nil();
501
+ return THIS->image() ? value(THIS->image()) : nil();
192
502
  }
193
503
 
194
504
  static
@@ -209,6 +519,7 @@ Init_style ()
209
519
  cStyle = rb_define_class_under(mReflex, "Style", rb_cObject);
210
520
  rb_define_alloc_func(cStyle, alloc);
211
521
  rb_define_private_method(cStyle, "initialize_copy", RUBY_METHOD_FUNC(initialize_copy), 1);
522
+
212
523
  rb_define_method(cStyle, "name=", RUBY_METHOD_FUNC(set_name), 1);
213
524
  rb_define_method(cStyle, "name", RUBY_METHOD_FUNC(get_name), 0);
214
525
  rb_define_method(cStyle, "add_tag", RUBY_METHOD_FUNC(add_tag), 1);
@@ -216,20 +527,69 @@ Init_style ()
216
527
  rb_define_method(cStyle, "each_tag", RUBY_METHOD_FUNC(each_tag), 0);
217
528
  rb_define_method(cStyle, "selector=", RUBY_METHOD_FUNC(set_selector), 1);
218
529
  rb_define_method(cStyle, "selector", RUBY_METHOD_FUNC(get_selector), 0);
530
+
219
531
  rb_define_method(cStyle, "set_flow", RUBY_METHOD_FUNC(set_flow), -1);
220
532
  rb_define_method(cStyle, "get_flow", RUBY_METHOD_FUNC(get_flow), 0);
221
- rb_define_method(cStyle, "size=", RUBY_METHOD_FUNC(set_size), 1);
533
+
534
+ rb_define_method(cStyle, "width=", RUBY_METHOD_FUNC(set_width), 1);
535
+ rb_define_method(cStyle, "width", RUBY_METHOD_FUNC(get_width), 0);
536
+ rb_define_method(cStyle, "height=", RUBY_METHOD_FUNC(set_height), 1);
537
+ rb_define_method(cStyle, "height", RUBY_METHOD_FUNC(get_height), 0);
538
+ rb_define_method(cStyle, "size=", RUBY_METHOD_FUNC(set_size), -1);
222
539
  rb_define_method(cStyle, "size", RUBY_METHOD_FUNC(get_size), 0);
223
- rb_define_method(cStyle, "position=", RUBY_METHOD_FUNC(set_position), 1);
540
+
541
+ rb_define_method(cStyle, "left=", RUBY_METHOD_FUNC(set_left), 1);
542
+ rb_define_method(cStyle, "left", RUBY_METHOD_FUNC(get_left), 0);
543
+ rb_define_method(cStyle, "top=", RUBY_METHOD_FUNC(set_top), 1);
544
+ rb_define_method(cStyle, "top", RUBY_METHOD_FUNC(get_top), 0);
545
+ rb_define_method(cStyle, "right=", RUBY_METHOD_FUNC(set_right), 1);
546
+ rb_define_method(cStyle, "right", RUBY_METHOD_FUNC(get_right), 0);
547
+ rb_define_method(cStyle, "bottom=", RUBY_METHOD_FUNC(set_bottom), 1);
548
+ rb_define_method(cStyle, "bottom", RUBY_METHOD_FUNC(get_bottom), 0);
549
+ rb_define_method(cStyle, "position=", RUBY_METHOD_FUNC(set_position), 4);
224
550
  rb_define_method(cStyle, "position", RUBY_METHOD_FUNC(get_position), 0);
225
- rb_define_method(cStyle, "margin=", RUBY_METHOD_FUNC(set_margin), 1);
551
+
552
+ rb_define_method(cStyle, "offset_left=", RUBY_METHOD_FUNC(set_offset_left), 1);
553
+ rb_define_method(cStyle, "offset_left", RUBY_METHOD_FUNC(get_offset_left), 0);
554
+ rb_define_method(cStyle, "offset_top=", RUBY_METHOD_FUNC(set_offset_top), 1);
555
+ rb_define_method(cStyle, "offset_top", RUBY_METHOD_FUNC(get_offset_top), 0);
556
+ rb_define_method(cStyle, "offset_right=", RUBY_METHOD_FUNC(set_offset_right), 1);
557
+ rb_define_method(cStyle, "offset_right", RUBY_METHOD_FUNC(get_offset_right), 0);
558
+ rb_define_method(cStyle, "offset_bottom=", RUBY_METHOD_FUNC(set_offset_bottom), 1);
559
+ rb_define_method(cStyle, "offset_bottom", RUBY_METHOD_FUNC(get_offset_bottom), 0);
560
+ rb_define_method(cStyle, "offset=", RUBY_METHOD_FUNC(set_offset), 4);
561
+ rb_define_method(cStyle, "offset", RUBY_METHOD_FUNC(get_offset), 0);
562
+
563
+ rb_define_method(cStyle, "margin_left=", RUBY_METHOD_FUNC(set_margin_left), 1);
564
+ rb_define_method(cStyle, "margin_left", RUBY_METHOD_FUNC(get_margin_left), 0);
565
+ rb_define_method(cStyle, "margin_top=", RUBY_METHOD_FUNC(set_margin_top), 1);
566
+ rb_define_method(cStyle, "margin_top", RUBY_METHOD_FUNC(get_margin_top), 0);
567
+ rb_define_method(cStyle, "margin_right=", RUBY_METHOD_FUNC(set_margin_right), 1);
568
+ rb_define_method(cStyle, "margin_right", RUBY_METHOD_FUNC(get_margin_right), 0);
569
+ rb_define_method(cStyle, "margin_bottom=", RUBY_METHOD_FUNC(set_margin_bottom), 1);
570
+ rb_define_method(cStyle, "margin_bottom", RUBY_METHOD_FUNC(get_margin_bottom), 0);
571
+ rb_define_method(cStyle, "margin=", RUBY_METHOD_FUNC(set_margin), 4);
226
572
  rb_define_method(cStyle, "margin", RUBY_METHOD_FUNC(get_margin), 0);
227
- rb_define_method(cStyle, "padding=", RUBY_METHOD_FUNC(set_padding), 1);
573
+
574
+ rb_define_method(cStyle, "padding_left=", RUBY_METHOD_FUNC(set_padding_left), 1);
575
+ rb_define_method(cStyle, "padding_left", RUBY_METHOD_FUNC(get_padding_left), 0);
576
+ rb_define_method(cStyle, "padding_top=", RUBY_METHOD_FUNC(set_padding_top), 1);
577
+ rb_define_method(cStyle, "padding_top", RUBY_METHOD_FUNC(get_padding_top), 0);
578
+ rb_define_method(cStyle, "padding_right=", RUBY_METHOD_FUNC(set_padding_right), 1);
579
+ rb_define_method(cStyle, "padding_right", RUBY_METHOD_FUNC(get_padding_right), 0);
580
+ rb_define_method(cStyle, "padding_bottom=", RUBY_METHOD_FUNC(set_padding_bottom), 1);
581
+ rb_define_method(cStyle, "padding_bottom", RUBY_METHOD_FUNC(get_padding_bottom), 0);
582
+ rb_define_method(cStyle, "padding=", RUBY_METHOD_FUNC(set_padding), 4);
228
583
  rb_define_method(cStyle, "padding", RUBY_METHOD_FUNC(get_padding), 0);
229
- rb_define_method(cStyle, "background_color=", RUBY_METHOD_FUNC(set_background_color), 1);
230
- rb_define_method(cStyle, "background_color", RUBY_METHOD_FUNC(get_background_color), 0);
231
- rb_define_method(cStyle, "background_image=", RUBY_METHOD_FUNC(set_background_image), 1);
232
- rb_define_method(cStyle, "background_image", RUBY_METHOD_FUNC(get_background_image), 0);
584
+
585
+ rb_define_method(cStyle, "fill=", RUBY_METHOD_FUNC(set_fill), 1);
586
+ rb_define_method(cStyle, "fill", RUBY_METHOD_FUNC(get_fill), 0);
587
+ rb_define_method(cStyle, "stroke=", RUBY_METHOD_FUNC(set_stroke), 1);
588
+ rb_define_method(cStyle, "stroke", RUBY_METHOD_FUNC(get_stroke), 0);
589
+
590
+ rb_define_method(cStyle, "image=", RUBY_METHOD_FUNC(set_image), 1);
591
+ rb_define_method(cStyle, "image", RUBY_METHOD_FUNC(get_image), 0);
592
+
233
593
  cStyle.define_method("==", equal);
234
594
  cStyle.define_const("FLOW_NONE", Reflex::Style::FLOW_NONE);
235
595
  cStyle.define_const("FLOW_DOWN", Reflex::Style::FLOW_DOWN);