Class: CGRect

Inherits:
Object
  • Object
show all
Defined in:
lib/geomotion/cg_rect.rb

Class Method Summary collapse

Instance Method Summary collapse

Class Method Details

.infinite ⇒ Object 



40
41
42
43
44
45
46
47
48
 
# File 'lib/geomotion/cg_rect.rb', line 40

def infinite
  # This actually returns the not-very-infinite value of:
  # [[-1.7014114289565e+38, -1.7014114289565e+38], [3.402822857913e+38, 3.402822857913e+38]]
  # originally this method returned [[-Infinity, -Infinity], [Infinity, Infinity]],
  # but that rect ended up returning `false` for any point in the method
  # CGRect.infinite.contains?(point).  CGRectInfinite returns `true` for any
  # (sensible) point, so we'll go with that instead
  CGRectInfinite.dup
end

.layout(rect1, options) ⇒ Object

OPTIONS: [:above, :below, :left_of, :right_of, :margins]

:margins is array of [top, right, bottom, left]

EX CGRect.layout(rect1, above: rect2, left_of: rect3, margins: [0, 10, 20, 0])



53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
 
# File 'lib/geomotion/cg_rect.rb', line 53

def layout(rect1, options)
  if options.empty?
    p "No options provided in #{self.class}.layout"
    return rect1
  end

  rect = self.new
  rect.size = rect1.size

  options[:margins] ||= []
  margins = {}
  [:top, :right, :bottom, :left].each_with_index do |margin, index|
    margins[margin] = options[:margins][index] || 0
  end

  rect.y = options[:above].up(rect.height + margins[:bottom]).y if options[:above]
  rect.y = options[:below].below(margins[:top]).y if options[:below]

  rect.x = options[:left_of].left(rect.width + margins[:right]).x if options[:left_of]
  rect.x = options[:right_of].beside(margins[:left]).x if options[:right_of]

  rect
end

.make(options = {}) ⇒ Object

CGRect.make # default rect: {x: 0, y: 0, size: height:0}

# aka CGRectZero

CGRect.make(x: 10, y: 30) # default size: [0, 0] CGRect.make(x: 10, y: 30, width:100, height: 20)

point = CGPoint.make(x: 10, y: 30) size = CGSize.make(width: 100, height: 20) CGRect.make(origin: point, size: size)



12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
 
# File 'lib/geomotion/cg_rect.rb', line 12

def make(options = {})
  if options[:origin]
    x = options[:origin][0]
    y = options[:origin][1]
  else
    x = options[:x] || 0
    y = options[:y] || 0
  end
  if options[:size]
    w = options[:size][0]
    h = options[:size][1]
  else
    w = options[:width] || 0
    h = options[:height] || 0
  end
  self.new([x, y], [w, h])
end

.null ⇒ Object 



35
36
37
38
 
# File 'lib/geomotion/cg_rect.rb', line 35

def null
  # Don't just return CGRectNull; can be mutated
  CGRect.new([Float::INFINITY, Float::INFINITY], [0, 0])
end

.zero ⇒ Object Also known as: empty 



30
31
32
 
# File 'lib/geomotion/cg_rect.rb', line 30

def zero
  CGRect.new([0, 0], [0, 0])
end

Instance Method Details

#*(scale) ⇒ Object 



497
498
499
500
501
502
503
504
 
# File 'lib/geomotion/cg_rect.rb', line 497

def *(scale)
  case scale
  when Numeric
    return CGRect.new(self.origin, self.size * scale)
  else
    super
  end
end

#+(other) ⇒ Object 



482
483
484
485
486
487
488
489
490
491
492
493
494
495
 
# File 'lib/geomotion/cg_rect.rb', line 482

def +(other)
  case other
  when CGRect
    return self.union_with(other)
  when CGSize
    return CGRect.new([self.origin.x, self.origin.y], [self.size.width + other.width, self.size.height + other.height])
  when CGPoint
    return self.offset(other.x, other.y)
  when UIOffset
    return self.offset(other.horizontal, other.vertical)
  when UIEdgeInsets
    return self.inset(other)
  end
end

#-(other) ⇒ Object 



659
660
661
 
# File 'lib/geomotion/cg_rect.rb', line 659

def -(other)
  self.+(-other)
end

#-@ ⇒ Object 



655
656
657
 
# File 'lib/geomotion/cg_rect.rb', line 655

def -@
  CGRect.new(-self.origin, -self.size)
end

#/(scale) ⇒ Object

it is tempting to define this as self * (1.0/scale) but floating point errors result in too many errors



508
509
510
511
512
513
514
515
 
# File 'lib/geomotion/cg_rect.rb', line 508

def /(scale)
  case scale
  when Numeric
    return CGRect.new(self.origin, self.size / scale)
  else
    super
  end
end

#==(rect) ⇒ Object 



651
652
653
 
# File 'lib/geomotion/cg_rect.rb', line 651

def ==(rect)
  rect.is_a?(CGRect) && CGRectEqualToRect(self, rect)
end

#above(margin = 0, options = {}) ⇒ Object

adjacent rects



321
322
323
324
325
326
327
328
329
 
# File 'lib/geomotion/cg_rect.rb', line 321

def above(margin = 0, options={})
  margin, options = 0, margin if margin.is_a?(NSDictionary)
  margin = options.delete(:margin) if options.key?(:margin)

  height = options[:height] || self.size.height
  self.apply({
    up: height + margin
    }).apply(options)
end

#apply(options) ⇒ Object

most rect modifiers call this method in one way or another



166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
 
# File 'lib/geomotion/cg_rect.rb', line 166

def apply(options)
  rect = CGRectStandardize(CGRect.new(self.origin, self.size))
  options.each do |method, value|
    case method
    when :left
      rect.origin.x -= value
    when :right
      rect.origin.x += value
    when :up
      rect.origin.y -= value
    when :down
      rect.origin.y += value
    when :wider, :grow_right
      rect.size.width += value
    when :thinner, :shrink_left
      rect.size.width -= value
    when :taller, :grow_down
      rect.size.height += value
    when :shorter, :shrink_up
      rect.size.height -= value
    when :x
      rect.origin.x = value
    when :y
      rect.origin.y = value
    when :origin
      rect.origin = value
    when :width
      rect.size.width = value
    when :height
      rect.size.height = value
    when :size
      rect.size = value
    when :grow
      rect = rect.grow(value)
    when :grow_up
      rect.size.height += value
      rect.origin.y -= value
    when :shrink_down
      rect.size.height -= value
      rect.origin.y += value
    when :grow_left
      rect.size.width += value
      rect.origin.x -= value
    when :shrink_right
      rect.size.width -= value
      rect.origin.x += value
    when :grow_width
      rect = rect.grow_width(value)
    when :grow_height
      rect = rect.grow_height(value)
    when :shrink
      rect = rect.shrink(value)
    when :shrink_width
      rect = rect.shrink_width(value)
    when :shrink_height
      rect = rect.shrink_height(value)
    when :offset
      rect = rect.offset(value)
    else
      raise "Unknow option #{method}"
    end
  end
  return rect
end

#before(margin = 0, options = {}) ⇒ Object 



340
341
342
343
344
345
346
347
348
 
# File 'lib/geomotion/cg_rect.rb', line 340

def before(margin = 0, options={})
  margin, options = 0, margin if margin.is_a?(NSDictionary)
  margin = options.delete(:margin) if options.key?(:margin)

  width = options[:width] || self.size.width
  self.apply({
    left: width + margin
    }).apply(options)
end

#below(margin = 0, options = {}) ⇒ Object 



331
332
333
334
335
336
337
338
 
# File 'lib/geomotion/cg_rect.rb', line 331

def below(margin = 0, options={})
  margin, options = 0, margin if margin.is_a?(NSDictionary)
  margin = options.delete(:margin) if options.key?(:margin)

  self.apply({
    down: self.size.height + margin
    }).apply(options)
end

#beside(margin = 0, options = {}) ⇒ Object Also known as: after 



350
351
352
353
354
355
356
357
 
# File 'lib/geomotion/cg_rect.rb', line 350

def beside(margin = 0, options={})
  margin, options = 0, margin if margin.is_a?(NSDictionary)
  margin = options.delete(:margin) if options.key?(:margin)

  self.apply({
    right: self.size.width + margin
    }).apply(options)
end

#bottom_center(absolute = false) ⇒ Object 



457
458
459
 
# File 'lib/geomotion/cg_rect.rb', line 457

def bottom_center(absolute = false)
  cgrect_offset(absolute) + CGPoint.new(self.size.width / 2, self.size.height)
end

#bottom_left(absolute = false) ⇒ Object 



461
462
463
 
# File 'lib/geomotion/cg_rect.rb', line 461

def bottom_left(absolute = false)
  cgrect_offset(absolute) + CGPoint.new(0, self.size.height)
end

#bottom_right(absolute = false) ⇒ Object 



453
454
455
 
# File 'lib/geomotion/cg_rect.rb', line 453

def bottom_right(absolute = false)
  cgrect_offset(absolute) + CGPoint.new(self.size.width, self.size.height)
end

#center(absolute = false) ⇒ Object 



433
434
435
 
# File 'lib/geomotion/cg_rect.rb', line 433

def center(absolute = false)
  cgrect_offset(absolute) + CGPoint.new(self.size.width / 2, self.size.height / 2)
end

#center_left(absolute = false) ⇒ Object 



465
466
467
 
# File 'lib/geomotion/cg_rect.rb', line 465

def center_left(absolute = false)
  cgrect_offset(absolute) + CGPoint.new(0, self.size.height / 2)
end

#center_right(absolute = false) ⇒ Object 



449
450
451
 
# File 'lib/geomotion/cg_rect.rb', line 449

def center_right(absolute = false)
  cgrect_offset(absolute) + CGPoint.new(self.size.width, self.size.height / 2)
end

#centered_in(rect, absolute = false) ⇒ Object 



478
479
480
 
# File 'lib/geomotion/cg_rect.rb', line 478

def centered_in(rect, absolute = false)
  self.size.centered_in(rect, absolute)
end

#contains?(rect_or_point) ⇒ Boolean

Returns:

  • (Boolean) 


640
641
642
643
644
645
646
647
648
649
 
# File 'lib/geomotion/cg_rect.rb', line 640

def contains?(rect_or_point)
  case rect_or_point
  when CGPoint
    CGRectContainsPoint(self, rect_or_point)
  when CGRect
    CGRectContainsRect(self, rect_or_point)
  else
    super  # raises an error
  end
end

#down(dist = nil, options = {}) ⇒ Object 



271
272
273
274
275
276
277
278
279
280
281
282
 
# File 'lib/geomotion/cg_rect.rb', line 271

def down(dist=nil, options={})
  if dist.nil?
    NSLog("Using the default value of `0` in `CGRect#down` is deprecated.")
    dist = 0
  end
  raise "You cannot specify `:down` in `CGRect#down`" if options.key?(:down)
  raise "You must specify an amount in `CGRect#down`" unless dist.is_a?(Numeric)

  self.apply({
    down: dist
    }).apply(options)
end

#empty? ⇒ Boolean

Returns:

  • (Boolean) 


619
620
621
 
# File 'lib/geomotion/cg_rect.rb', line 619

def empty?
  CGRectIsEmpty(self)
end

#from_bottom(options = {}) ⇒ Object

Create a rect inside the receiver, on the bottom side. If ‘margin` is supplied, the rect will be moved that number of points up.



409
410
411
412
413
414
415
416
417
418
419
420
 
# File 'lib/geomotion/cg_rect.rb', line 409

def from_bottom(options={})
  height = options[:height]
  margin = options.delete(:margin) || 0
  raise "You must specify a height in `CGRect#from_bottom`" unless height
  offset = cgrect_offset(options.delete(:absolute))
  self.apply({
    x: offset.x,
    y: offset.y + self.size.height - height - margin,
    width: self.size.width,
    height: height,
    }).apply(options)
end

#from_left(options = {}) ⇒ Object

Create a rect inside the receiver, on the left side. If ‘margin` is supplied, the rect will be moved that number of points to the right.



364
365
366
367
368
369
370
371
372
373
374
375
 
# File 'lib/geomotion/cg_rect.rb', line 364

def from_left(options={})
  width = options[:width]
  margin = options.delete(:margin) || 0
  raise "You must specify a width in `CGRect#from_left`" unless width
  offset = cgrect_offset(options.delete(:absolute))
  self.apply({
    x: offset.x + margin,
    y: offset.y,
    width: width,
    height: self.size.height,
    }).apply(options)
end

#from_right(options = {}) ⇒ Object

Create a rect inside the receiver, on the right side. If ‘margin` is supplied, the rect will be moved that number of points to the left.



379
380
381
382
383
384
385
386
387
388
389
390
 
# File 'lib/geomotion/cg_rect.rb', line 379

def from_right(options={})
  width = options[:width]
  margin = options.delete(:margin) || 0
  raise "You must specify a width in `CGRect#from_right`" unless width
  offset = cgrect_offset(options.delete(:absolute))
  self.apply({
    x: offset.x + self.size.width - width - margin,
    y: offset.y,
    width: width,
    height: self.size.height,
    }).apply(options)
end

#from_top(options = {}) ⇒ Object

Create a rect inside the receiver, on the top side. If ‘margin` is supplied, the rect will be moved that number of points down.



394
395
396
397
398
399
400
401
402
403
404
405
 
# File 'lib/geomotion/cg_rect.rb', line 394

def from_top(options={})
  height = options[:height]
  margin = options.delete(:margin) || 0
  raise "You must specify a height in `CGRect#from_top`" unless height
  offset = cgrect_offset(options.delete(:absolute))
  self.apply({
    x: offset.x,
    y: offset.y + margin,
    width: self.size.width,
    height: height,
    }).apply(options)
end

#grow(size, options = nil) ⇒ Object 



537
538
539
540
541
542
543
544
545
546
 
# File 'lib/geomotion/cg_rect.rb', line 537

def grow(size, options=nil)
  if size.is_a? Numeric
    size = CGSize.new(size, size)
  end
  rect = CGRectInset(self, -size[0], -size[1])
  if options
    return rect.apply(options)
  end
  return rect
end

#grow_height(amount, options = {}) ⇒ Object 



574
575
576
 
# File 'lib/geomotion/cg_rect.rb', line 574

def grow_height(amount, options={})
  return self.grow([0, amount], options)
end

#grow_left(amount, options = {}) ⇒ Object 



550
551
552
553
554
555
556
557
 
# File 'lib/geomotion/cg_rect.rb', line 550

def grow_left(amount, options={})
  raise "You cannot specify `:grow_left` in `CGRect#grow_left`" if options.key?(:grow_left)
  raise "You must specify an amount in `CGRect#grow_left`" unless amount.is_a?(Numeric)

  self.apply({
    grow_left: amount
    }).apply(options)
end

#grow_up(amount, options = {}) ⇒ Object 



561
562
563
564
565
566
567
568
 
# File 'lib/geomotion/cg_rect.rb', line 561

def grow_up(amount, options={})
  raise "You cannot specify `:grow_up` in `CGRect#grow_up`" if options.key?(:grow_up)
  raise "You must specify an amount in `CGRect#grow_up`" unless amount.is_a?(Numeric)

  self.apply({
    grow_up: amount
    }).apply(options)
end

#grow_width(amount, options = {}) ⇒ Object 



570
571
572
 
# File 'lib/geomotion/cg_rect.rb', line 570

def grow_width(amount, options={})
  return self.grow([amount, 0], options)
end

#height(setter = nil, options = nil) ⇒ Object 



150
151
152
153
154
155
156
157
158
159
 
# File 'lib/geomotion/cg_rect.rb', line 150

def height(setter=nil, options=nil)
  if setter
    rect = CGRect.new(self.origin, [self.size.width, setter])
    if options
      return rect.apply(options)
    end
    return rect
  end
  return CGRectGetHeight(self)
end

#height=(_height) ⇒ Object 



161
162
163
 
# File 'lib/geomotion/cg_rect.rb', line 161

def height=(_height)
  self.size.height = _height
end

#infinite? ⇒ Boolean

Returns:

  • (Boolean) 


623
624
625
 
# File 'lib/geomotion/cg_rect.rb', line 623

def infinite?
  self.size.infinite? || CGRectEqualToRect(self, CGRectInfinite)
end

#inset(insets) ⇒ Object 



525
526
527
 
# File 'lib/geomotion/cg_rect.rb', line 525

def inset(insets)
  UIEdgeInsetsInsetRect(self, insets)
end

#inspect ⇒ Object 



663
664
665
 
# File 'lib/geomotion/cg_rect.rb', line 663

def inspect
  "#{self.class.name}([#{self.origin.x}, #{self.origin.y}], [#{self.size.width}, #{self.size.height}])"
end

#integral ⇒ Object 



474
475
476
 
# File 'lib/geomotion/cg_rect.rb', line 474

def integral
  CGRectIntegral(self)
end

#intersection_with(rect) ⇒ Object 



517
518
519
 
# File 'lib/geomotion/cg_rect.rb', line 517

def intersection_with(rect)
  CGRectIntersection(self, rect)
end

#intersects?(rect) ⇒ Boolean

Returns:

  • (Boolean) 


631
632
633
634
635
636
637
638
 
# File 'lib/geomotion/cg_rect.rb', line 631

def intersects?(rect)
  case rect
  when CGRect
    CGRectIntersectsRect(self, rect)
  else
    super  # raises an error
  end
end

#left(dist = nil, options = {}) ⇒ Object

modified rects



232
233
234
235
236
237
238
239
240
241
242
243
 
# File 'lib/geomotion/cg_rect.rb', line 232

def left(dist=nil, options={})
  if dist.nil?
    NSLog("Using the default value of `0` in `CGRect#left` is deprecated.")
    dist = 0
  end
  raise "You cannot specify `:left` in `CGRect#left`" if options.key?(:left)
  raise "You must specify an amount in `CGRect#left`" unless dist.is_a?(Numeric)

  self.apply({
    left: dist
    }).apply(options)
end

#max_x ⇒ Object 



88
89
90
 
# File 'lib/geomotion/cg_rect.rb', line 88

def max_x
  CGRectGetMaxX(self)
end

#max_y ⇒ Object 



100
101
102
 
# File 'lib/geomotion/cg_rect.rb', line 100

def max_y
  CGRectGetMaxY(self)
end

#mid_x ⇒ Object 



84
85
86
 
# File 'lib/geomotion/cg_rect.rb', line 84

def mid_x
  CGRectGetMidX(self)
end

#mid_y ⇒ Object 



96
97
98
 
# File 'lib/geomotion/cg_rect.rb', line 96

def mid_y
  CGRectGetMidY(self)
end

#min_x ⇒ Object

bounds



80
81
82
 
# File 'lib/geomotion/cg_rect.rb', line 80

def min_x
  CGRectGetMinX(self)
end

#min_y ⇒ Object 



92
93
94
 
# File 'lib/geomotion/cg_rect.rb', line 92

def min_y
  CGRectGetMinY(self)
end

#null? ⇒ Boolean

Returns:

  • (Boolean) 


627
628
629
 
# File 'lib/geomotion/cg_rect.rb', line 627

def null?
  CGRectIsNull(self)
end

#offset(point_or_x, y = nil) ⇒ Object 



529
530
531
532
533
534
535
 
# File 'lib/geomotion/cg_rect.rb', line 529

def offset(point_or_x, y=nil)
  if y
    CGRectOffset(self, point_or_x, y)
  else
    CGRectOffset(self, point_or_x[0], point_or_x[1])
  end
end

#right(dist = nil, options = {}) ⇒ Object 



245
246
247
248
249
250
251
252
253
254
255
256
 
# File 'lib/geomotion/cg_rect.rb', line 245

def right(dist=nil, options={})
  if dist.nil?
    NSLog("Using the default value of `0` in `CGRect#right` is deprecated.")
    dist = 0
  end
  raise "You cannot specify `:right` in `CGRect#right`" if options.key?(:right)
  raise "You must specify an amount in `CGRect#right`" unless dist.is_a?(Numeric)

  self.apply({
    right: dist
    }).apply(options)
end

#round ⇒ Object

others



470
471
472
 
# File 'lib/geomotion/cg_rect.rb', line 470

def round
  CGRect.new([self.origin.x.round, self.origin.y.round], [self.size.width.round, self.size.height.round])
end

#shorter(dist, options = {}) ⇒ Object Also known as: shrink_up 



311
312
313
314
315
316
317
318
 
# File 'lib/geomotion/cg_rect.rb', line 311

def shorter(dist, options={})
  raise "You cannot specify `:shorter` in `CGRect#shorter`" if options.key?(:shorter)
  raise "You must specify an amount in `CGRect#shorter`" unless dist.is_a?(Numeric)

  self.apply({
    shorter: dist
    }).apply(options)
end

#shrink(size, options = nil) ⇒ Object 



578
579
580
581
582
583
584
585
586
587
 
# File 'lib/geomotion/cg_rect.rb', line 578

def shrink(size, options=nil)
  if size.is_a? Numeric
    size = CGSize.new(size, size)
  end
  rect = CGRectInset(self, size[0], size[1])
  if options
    return rect.apply(options)
  end
  return rect
end

#shrink_down(amount, options = {}) ⇒ Object 



602
603
604
605
606
607
608
609
 
# File 'lib/geomotion/cg_rect.rb', line 602

def shrink_down(amount, options={})
  raise "You cannot specify `:shrink_down` in `CGRect#shrink_down`" if options.key?(:shrink_down)
  raise "You must specify an amount in `CGRect#shrink_down`" unless amount.is_a?(Numeric)

  self.apply({
    shrink_down: amount
    }).apply(options)
end

#shrink_height(amount, options = {}) ⇒ Object 



615
616
617
 
# File 'lib/geomotion/cg_rect.rb', line 615

def shrink_height(amount, options={})
  return self.shrink([0, amount], options)
end

#shrink_right(amount, options = {}) ⇒ Object 



591
592
593
594
595
596
597
598
 
# File 'lib/geomotion/cg_rect.rb', line 591

def shrink_right(amount, options={})
  raise "You cannot specify `:shrink_right` in `CGRect#shrink_right`" if options.key?(:shrink_right)
  raise "You must specify an amount in `CGRect#shrink_right`" unless amount.is_a?(Numeric)

  self.apply({
    shrink_right: amount
    }).apply(options)
end

#shrink_width(amount, options = {}) ⇒ Object 



611
612
613
 
# File 'lib/geomotion/cg_rect.rb', line 611

def shrink_width(amount, options={})
  return self.shrink([amount, 0], options)
end

#taller(dist, options = {}) ⇒ Object Also known as: grow_down 



302
303
304
305
306
307
308
309
 
# File 'lib/geomotion/cg_rect.rb', line 302

def taller(dist, options={})
  raise "You cannot specify `:taller` in `CGRect#taller`" if options.key?(:taller)
  raise "You must specify an amount in `CGRect#taller`" unless dist.is_a?(Numeric)

  self.apply({
    taller: dist
    }).apply(options)
end

#thinner(dist, options = {}) ⇒ Object Also known as: shrink_left 



293
294
295
296
297
298
299
300
 
# File 'lib/geomotion/cg_rect.rb', line 293

def thinner(dist, options={})
  raise "You cannot specify `:thinner` in `CGRect#thinner`" if options.key?(:thinner)
  raise "You must specify an amount in `CGRect#thinner`" unless dist.is_a?(Numeric)

  self.apply({
    thinner: dist
    }).apply(options)
end

#to_ns_value ⇒ Object 



667
668
669
 
# File 'lib/geomotion/cg_rect.rb', line 667

def to_ns_value
  NSValue.valueWithCGRect(self)
end

#top_center(absolute = false) ⇒ Object 



441
442
443
 
# File 'lib/geomotion/cg_rect.rb', line 441

def top_center(absolute = false)
  cgrect_offset(absolute) + CGPoint.new(self.size.width / 2, 0)
end

#top_left(absolute = false) ⇒ Object 



437
438
439
 
# File 'lib/geomotion/cg_rect.rb', line 437

def top_left(absolute = false)
  cgrect_offset(absolute) + CGPoint.new(0, 0)
end

#top_right(absolute = false) ⇒ Object 



445
446
447
 
# File 'lib/geomotion/cg_rect.rb', line 445

def top_right(absolute = false)
  cgrect_offset(absolute) + CGPoint.new(self.size.width, 0)
end

#union_with(rect) ⇒ Object 



521
522
523
 
# File 'lib/geomotion/cg_rect.rb', line 521

def union_with(rect)
  CGRectUnion(self, rect)
end

#up(dist = nil, options = {}) ⇒ Object 



258
259
260
261
262
263
264
265
266
267
268
269
 
# File 'lib/geomotion/cg_rect.rb', line 258

def up(dist=nil, options={})
  if dist.nil?
    NSLog("Using the default value of `0` in `CGRect#up` is deprecated.")
    dist = 0
  end
  raise "You cannot specify `:up` in `CGRect#up`" if options.key?(:up)
  raise "You must specify an amount in `CGRect#up`" unless dist.is_a?(Numeric)

  self.apply({
    up: dist
    }).apply(options)
end

#wider(dist, options = {}) ⇒ Object Also known as: grow_right 



284
285
286
287
288
289
290
291
 
# File 'lib/geomotion/cg_rect.rb', line 284

def wider(dist, options={})
  raise "You cannot specify `:width` in `CGRect#width`" if options.key?(:width)
  raise "You must specify an amount in `CGRect#wider`" unless dist.is_a?(Numeric)

  self.apply({
    wider: dist
    }).apply(options)
end

#width(setter = nil, options = nil) ⇒ Object 



135
136
137
138
139
140
141
142
143
144
 
# File 'lib/geomotion/cg_rect.rb', line 135

def width(setter=nil, options=nil)
  if setter
    rect = CGRect.new(self.origin, [setter, self.size.height])
    if options
      return rect.apply(options)
    end
    return rect
  end
  return CGRectGetWidth(self)
end

#width=(_width) ⇒ Object 



146
147
148
 
# File 'lib/geomotion/cg_rect.rb', line 146

def width=(_width)
  self.size.width = _width
end

#x(setter = nil, options = nil) ⇒ Object

getters/setters



105
106
107
108
109
110
111
112
113
114
 
# File 'lib/geomotion/cg_rect.rb', line 105

def x(setter=nil, options=nil)
  if setter
    rect = CGRect.new([setter, self.origin.y], self.size)
    if options
      return rect.apply(options)
    end
    return rect
  end
  return min_x
end

#x=(_x) ⇒ Object 



116
117
118
 
# File 'lib/geomotion/cg_rect.rb', line 116

def x=(_x)
  self.origin.x = _x
end

#y(setter = nil, options = nil) ⇒ Object 



120
121
122
123
124
125
126
127
128
129
 
# File 'lib/geomotion/cg_rect.rb', line 120

def y(setter=nil, options=nil)
  if setter
    rect = CGRect.new([self.origin.x, setter], self.size)
    if options
      return rect.apply(options)
    end
    return rect
  end
  return min_y
end

#y=(_y) ⇒ Object 



131
132
133
 
# File 'lib/geomotion/cg_rect.rb', line 131

def y=(_y)
  self.origin.y = _y
end