Class: Wx::Rect

Inherits:
Object
  • Object
show all
Defined in:
lib/wx/doc/gen/gdi_common.rb,
lib/wx/doc/gdi_common.rb

Overview

Note:

This class is untracked and should not be derived from nor instances extended!

Represents a rectangle with integer coordinates.

x and y members specify the coordinates of the rectangle top-left corner and width and height specify its width and height respectively. The usual C++ semi-open interval convention is used: point p lies inside the rectangle if and only if both conditions below are satisfied:

x <= p.x < x + width
  y <= p.y < y + height

In other words, the rectangle left and right boundaries are at x and x+width-1 and its top and bottom boundaries are at y and y+height-1 respectively. Note that the x and y coordinates may be negative, but width and height are always strictly positive for non-empty rectangles.

Category: Data Structures

See Also:

Instance Method Summary collapse

Constructor Details

#initialize ⇒ Wx::Rect #initialize(x, y, width, height) ⇒ Wx::Rect #initialize(topLeft, bottomRight) ⇒ Wx::Rect #initialize(pos, size) ⇒ Wx::Rect #initialize(size) ⇒ Wx::Rect

Returns a new instance of Rect.

Overloads:

  • #initialize ⇒ Wx::Rect

    Default constructor.

    Initializes to zero the internal x, y, width and height members.

  • #initialize(x, y, width, height) ⇒ Wx::Rect

    Creates a Wx::Rect object from x, y, width and height values.

    Parameters:

    • x (Integer)
    • y (Integer)
    • width (Integer)
    • height (Integer)
  • #initialize(topLeft, bottomRight) ⇒ Wx::Rect

    Creates a Wx::Rect object from top-left and bottom-right points.

    The width of the rectangle will be bottomRight.x-topLeft.x+1 and the height will be bottomRight.y-topLeft.y+1.

    Parameters:

  • #initialize(pos, size) ⇒ Wx::Rect

    Creates a Wx::Rect object from position pos and size values.

    Parameters:

  • #initialize(size) ⇒ Wx::Rect

    Creates a Wx::Rect object from size values at the origin.

    Parameters:

    • size (Array(Integer, Integer), Wx::Size) 


755
 
# File 'lib/wx/doc/gen/gdi_common.rb', line 755

def initialize(*args) end

Instance Method Details

#& ⇒ Object 



319
 
# File 'lib/wx/doc/gdi_common.rb', line 319

alias :& :intersect

#*(rect) ⇒ Wx::Rect

Returns the overlap of the rectangle areas. Does not check negative or zero overlap like #intersect.

Parameters:

Returns:



327
 
# File 'lib/wx/doc/gdi_common.rb', line 327

def *(rect) end

#+(rect) ⇒ Wx::Rect

Returns a rectangle containing the bounding box of this rectangle and the one passed in as parameter. Does not ignore empty rectangles like #union

Parameters:

Returns:



333
 
# File 'lib/wx/doc/gdi_common.rb', line 333

def +(rect) end

#==(other) ⇒ Boolean

Compare area values (Wx::Rect or 4-element array). Returns false if incompatible.

Parameters:

  • other (Wx::Rect, Array(Integer,Integer,Integer,Integer))

Returns:

  • (Boolean) 


230
 
# File 'lib/wx/doc/gdi_common.rb', line 230

def ==(other)end

#assign(rct) ⇒ self

Set this rectangle to the given rectangle’s position & size values

Parameters:

Returns:

  • (self) 


338
 
# File 'lib/wx/doc/gdi_common.rb', line 338

def assign(rct) end

#center_in(r, dir = Wx::Orientation::BOTH) ⇒ Wx::Rect

Returns the rectangle having the same size as this one but centered relatively to the given rectangle r.

By default, rectangle is centred in both directions but if dir includes only Orientation::VERTICAL or only Orientation::HORIZONTAL, then it is only centered in this direction while the other component of its position remains unchanged.

Parameters:

  • r (Wx::Rect)
  • dir (Integer) (defaults to: Wx::Orientation::BOTH)

Returns:



663
 
# File 'lib/wx/doc/gen/gdi_common.rb', line 663

def center_in(r, dir=Wx::Orientation::BOTH) end

#centre_in(r, dir = Wx::Orientation::BOTH) ⇒ Wx::Rect

Returns the rectangle having the same size as this one but centered relatively to the given rectangle r.

By default, rectangle is centred in both directions but if dir includes only Orientation::VERTICAL or only Orientation::HORIZONTAL, then it is only centered in this direction while the other component of its position remains unchanged.

Parameters:

  • r (Wx::Rect)
  • dir (Integer) (defaults to: Wx::Orientation::BOTH)

Returns:



655
 
# File 'lib/wx/doc/gen/gdi_common.rb', line 655

def centre_in(r, dir=Wx::Orientation::BOTH) end

#contains(x, y) ⇒ Boolean #contains(pt) ⇒ Boolean #contains(rect) ⇒ Boolean

Overloads:

  • #contains(x, y) ⇒ Boolean

    Returns true if the given point is inside the rectangle (or on its boundary) and false otherwise.

    Parameters:

    • x (Integer)
    • y (Integer)

    Returns:

    • (Boolean)
  • #contains(pt) ⇒ Boolean

    Returns true if the given point is inside the rectangle (or on its boundary) and false otherwise.

    Parameters:

    Returns:

    • (Boolean)
  • #contains(rect) ⇒ Boolean

    Returns true if the given rectangle is completely inside this rectangle (or touches its boundary) and false otherwise.

    Parameters:

    Returns:

    • (Boolean) 


770
 
# File 'lib/wx/doc/gen/gdi_common.rb', line 770

def contains(*args) end

#deflate(dx, dy) ⇒ Wx::Rect #deflate(diff) ⇒ Wx::Rect #deflate(diff) ⇒ Wx::Rect

Overloads:

  • #deflate(dx, dy) ⇒ Wx::Rect

    Decrease the rectangle size.

    This method is the opposite from #inflate: Deflate(a, b) is equivalent to Inflate(-a, -b). Please refer to #inflate for full description.

    Parameters:

    • dx (Integer)
    • dy (Integer)

    Returns:

  • #deflate(diff) ⇒ Wx::Rect

    Decrease the rectangle size.

    This method is the opposite from #inflate: Deflate(a, b) is equivalent to Inflate(-a, -b). Please refer to #inflate for full description.

    Parameters:

    • diff (Array(Integer, Integer), Wx::Size)

    Returns:

  • #deflate(diff) ⇒ Wx::Rect

    Decrease the rectangle size.

    This method is the opposite from #inflate: Deflate(a, b) is equivalent to Inflate(-a, -b). Please refer to #inflate for full description.

    Parameters:

    • diff (Integer)

    Returns:



684
 
# File 'lib/wx/doc/gen/gdi_common.rb', line 684

def deflate(*args) end

#deflate!(dx, dy) ⇒ self #deflate!(diff) ⇒ self #deflate!(diff) ⇒ self

Overloads:

  • #deflate!(dx, dy) ⇒ self

    Decrease the rectangle size. This method is the opposite from #inflate!: deflate!(a, b) is equivalent to inflate!(-a, -b). Please refer to #inflate! for full description.

    Parameters:

    • dx (Integer)
    • dy (Integer)

    Returns:

    • (self)
  • #deflate!(diff) ⇒ self

    Decrease the rectangle size. This method is the opposite from #inflate!: deflate!(a, b) is equivalent to inflate!(-a, -b). Please refer to #inflate! for full description.

    Parameters:

    • diff (Array(Integer, Integer), Wx::Size)

    Returns:

    • (self)
  • #deflate!(diff) ⇒ self

    Decrease the rectangle size. This method is the opposite from #inflate!: deflate!(a, b) is equivalent to inflate!(-a, -b). Please refer to #inflate! for full description.

    Parameters:

    • diff (Integer)

    Returns:

    • (self) 


263
 
# File 'lib/wx/doc/gdi_common.rb', line 263

def deflate!(*args) end

#eql?(other) ⇒ Boolean

Compare areas.

Parameters:

Returns:

  • (Boolean) 


235
 
# File 'lib/wx/doc/gdi_common.rb', line 235

def eql?(other)end

#get_bottom ⇒ Integer Also known as: bottom

Gets the bottom point of the rectangle.

Returns:

  • (Integer) 


774
 
# File 'lib/wx/doc/gen/gdi_common.rb', line 774

def get_bottom; end

#get_bottom_left ⇒ Wx::Point Also known as: bottom_left

Gets the position of the bottom left corner.

Returns:



779
 
# File 'lib/wx/doc/gen/gdi_common.rb', line 779

def get_bottom_left; end

#get_bottom_right ⇒ Wx::Point Also known as: bottom_right

Gets the position of the bottom right corner.

Returns:



784
 
# File 'lib/wx/doc/gen/gdi_common.rb', line 784

def get_bottom_right; end

#get_height ⇒ Integer Also known as: height

Gets the height member.

Returns:

  • (Integer) 


789
 
# File 'lib/wx/doc/gen/gdi_common.rb', line 789

def get_height; end

#get_left ⇒ Integer Also known as: left

Gets the left point of the rectangle (the same as #get_x).

Returns:

  • (Integer) 


794
 
# File 'lib/wx/doc/gen/gdi_common.rb', line 794

def get_left; end

#get_position ⇒ Wx::Point Also known as: position

Gets the position.

Returns:



799
 
# File 'lib/wx/doc/gen/gdi_common.rb', line 799

def get_position; end

#get_right ⇒ Integer Also known as: right

Gets the right point of the rectangle.

Returns:

  • (Integer) 


804
 
# File 'lib/wx/doc/gen/gdi_common.rb', line 804

def get_right; end

#get_size ⇒ Wx::Size Also known as: size

Gets the size.

Returns:

See Also:



812
 
# File 'lib/wx/doc/gen/gdi_common.rb', line 812

def get_size; end

#get_top ⇒ Integer Also known as: top

Gets the top point of the rectangle (the same as #get_y).

Returns:

  • (Integer) 


817
 
# File 'lib/wx/doc/gen/gdi_common.rb', line 817

def get_top; end

#get_top_left ⇒ Wx::Point Also known as: top_left

Gets the position of the top left corner of the rectangle, same as #get_position.

Returns:



822
 
# File 'lib/wx/doc/gen/gdi_common.rb', line 822

def get_top_left; end

#get_top_right ⇒ Wx::Point Also known as: top_right

Gets the position of the top right corner.

Returns:



827
 
# File 'lib/wx/doc/gen/gdi_common.rb', line 827

def get_top_right; end

#get_width ⇒ Integer Also known as: width

Gets the width member.

Returns:

  • (Integer) 


832
 
# File 'lib/wx/doc/gen/gdi_common.rb', line 832

def get_width; end

#get_x ⇒ Integer Also known as: x

Gets the x member.

Returns:

  • (Integer) 


837
 
# File 'lib/wx/doc/gen/gdi_common.rb', line 837

def get_x; end

#get_y ⇒ Integer Also known as: y

Gets the y member.

Returns:

  • (Integer) 


842
 
# File 'lib/wx/doc/gen/gdi_common.rb', line 842

def get_y; end

#inflate(dx, dy) ⇒ Wx::Rect #inflate(diff) ⇒ Wx::Rect #inflate(diff) ⇒ Wx::Rect

Overloads:

  • #inflate(dx, dy) ⇒ Wx::Rect

    Increases the size of the rectangle.

    The left border is moved farther left and the right border is moved farther right by dx. The upper border is moved farther up and the bottom border is moved farther down by dy. (Note that the width and height of the rectangle thus change by 2dx and 2dy, respectively.) If one or both of dx and dy are negative, the opposite happens: the rectangle size decreases in the respective direction. Inflating and deflating behaves “naturally”. Defined more precisely, that means:

    • “Real” inflates (that is, dx and/or dy = 0) are not constrained. Thus inflating a rectangle can cause its upper left corner to move into the negative numbers. (2.5.4 and older forced the top left coordinate to not fall below (0, 0), which implied a forced move of the rectangle.)

    • Deflates are clamped to not reduce the width or height of the rectangle below zero. In such cases, the top-left corner is nonetheless handled properly. For example, a rectangle at (10, 10) with size (20, 40) that is inflated by (-15, -15) will become located at (20, 25) at size (0, 10). Finally, observe that the width and height are treated independently. In the above example, the width is reduced by 20, whereas the height is reduced by the full 30 (rather than also stopping at 20, when the width reached zero).

    Parameters:

    • dx (Integer)
    • dy (Integer)

    Returns:

    See Also:

  • #inflate(diff) ⇒ Wx::Rect

    Increases the size of the rectangle.

    The left border is moved farther left and the right border is moved farther right by dx. The upper border is moved farther up and the bottom border is moved farther down by dy. (Note that the width and height of the rectangle thus change by 2dx and 2dy, respectively.) If one or both of dx and dy are negative, the opposite happens: the rectangle size decreases in the respective direction. Inflating and deflating behaves “naturally”. Defined more precisely, that means:

    • “Real” inflates (that is, dx and/or dy = 0) are not constrained. Thus inflating a rectangle can cause its upper left corner to move into the negative numbers. (2.5.4 and older forced the top left coordinate to not fall below (0, 0), which implied a forced move of the rectangle.)

    • Deflates are clamped to not reduce the width or height of the rectangle below zero. In such cases, the top-left corner is nonetheless handled properly. For example, a rectangle at (10, 10) with size (20, 40) that is inflated by (-15, -15) will become located at (20, 25) at size (0, 10). Finally, observe that the width and height are treated independently. In the above example, the width is reduced by 20, whereas the height is reduced by the full 30 (rather than also stopping at 20, when the width reached zero).

    Parameters:

    • diff (Array(Integer, Integer), Wx::Size)

    Returns:

    See Also:

  • #inflate(diff) ⇒ Wx::Rect

    Increases the size of the rectangle.

    The left border is moved farther left and the right border is moved farther right by dx. The upper border is moved farther up and the bottom border is moved farther down by dy. (Note that the width and height of the rectangle thus change by 2dx and 2dy, respectively.) If one or both of dx and dy are negative, the opposite happens: the rectangle size decreases in the respective direction. Inflating and deflating behaves “naturally”. Defined more precisely, that means:

    • “Real” inflates (that is, dx and/or dy = 0) are not constrained. Thus inflating a rectangle can cause its upper left corner to move into the negative numbers. (2.5.4 and older forced the top left coordinate to not fall below (0, 0), which implied a forced move of the rectangle.)

    • Deflates are clamped to not reduce the width or height of the rectangle below zero. In such cases, the top-left corner is nonetheless handled properly. For example, a rectangle at (10, 10) with size (20, 40) that is inflated by (-15, -15) will become located at (20, 25) at size (0, 10). Finally, observe that the width and height are treated independently. In the above example, the width is reduced by 20, whereas the height is reduced by the full 30 (rather than also stopping at 20, when the width reached zero).

    Parameters:

    • diff (Integer)

    Returns:

    See Also:



720
 
# File 'lib/wx/doc/gen/gdi_common.rb', line 720

def inflate(*args) end

#inflate!(dx, dy) ⇒ self #inflate!(diff) ⇒ self #inflate!(diff) ⇒ self

Overloads:

  • #inflate!(dx, dy) ⇒ self

    Increases the size of the rectangle. The left border is moved farther left and the right border is moved farther right by dx. The upper border is moved farther up and the bottom border is moved farther down by dy. (Note that the width and height of the rectangle thus change by 2dx and 2dy, respectively.) If one or both of dx and dy are negative, the opposite happens: the rectangle size decreases in the respective direction. Inflating and deflating behaves “naturally”. Defined more precisely, that means: - “Real” inflates (that is, dx and/or dy = 0) are not constrained. Thus inflating a rectangle can cause its upper left corner to move into the negative numbers. (2.5.4 and older forced the top left coordinate to not fall below (0, 0), which implied a forced move of the rectangle.)- Deflates are clamped to not reduce the width or height of the rectangle below zero. In such cases, the top-left corner is nonetheless handled properly. For example, a rectangle at (10, 10) with size (20, 40) that is inflated by (-15, -15) will become located at (20, 25) at size (0, 10). Finally, observe that the width and height are treated independently. In the above example, the width is reduced by 20, whereas the height is reduced by the full 30 (rather than also stopping at 20, when the width reached zero).

    Parameters:

    • dx (Integer)
    • dy (Integer)

    Returns:

    • (self)

    See Also:

  • #inflate!(diff) ⇒ self

    Increases the size of the rectangle. The left border is moved farther left and the right border is moved farther right by dx. The upper border is moved farther up and the bottom border is moved farther down by dy. (Note that the width and height of the rectangle thus change by 2dx and 2dy, respectively.) If one or both of dx and dy are negative, the opposite happens: the rectangle size decreases in the respective direction. Inflating and deflating behaves “naturally”. Defined more precisely, that means: - “Real” inflates (that is, dx and/or dy = 0) are not constrained. Thus inflating a rectangle can cause its upper left corner to move into the negative numbers. (2.5.4 and older forced the top left coordinate to not fall below (0, 0), which implied a forced move of the rectangle.)- Deflates are clamped to not reduce the width or height of the rectangle below zero. In such cases, the top-left corner is nonetheless handled properly. For example, a rectangle at (10, 10) with size (20, 40) that is inflated by (-15, -15) will become located at (20, 25) at size (0, 10). Finally, observe that the width and height are treated independently. In the above example, the width is reduced by 20, whereas the height is reduced by the full 30 (rather than also stopping at 20, when the width reached zero).

    Parameters:

    • diff (Array(Integer, Integer), Wx::Size)

    Returns:

    • (self)

    See Also:

  • #inflate!(diff) ⇒ self

    Increases the size of the rectangle. The left border is moved farther left and the right border is moved farther right by dx. The upper border is moved farther up and the bottom border is moved farther down by dy. (Note that the width and height of the rectangle thus change by 2dx and 2dy, respectively.) If one or both of dx and dy are negative, the opposite happens: the rectangle size decreases in the respective direction. Inflating and deflating behaves “naturally”. Defined more precisely, that means: - “Real” inflates (that is, dx and/or dy = 0) are not constrained. Thus inflating a rectangle can cause its upper left corner to move into the negative numbers. (2.5.4 and older forced the top left coordinate to not fall below (0, 0), which implied a forced move of the rectangle.)- Deflates are clamped to not reduce the width or height of the rectangle below zero. In such cases, the top-left corner is nonetheless handled properly. For example, a rectangle at (10, 10) with size (20, 40) that is inflated by (-15, -15) will become located at (20, 25) at size (0, 10). Finally, observe that the width and height are treated independently. In the above example, the width is reduced by 20, whereas the height is reduced by the full 30 (rather than also stopping at 20, when the width reached zero).

    Parameters:

    • diff (Integer)

    Returns:

    • (self)

    See Also:



291
 
# File 'lib/wx/doc/gdi_common.rb', line 291

def inflate!(*args) end

#intersect(rect) ⇒ Wx::Rect

Returns the overlapping portion of this rectangle and the one passed in as parameter.

Parameters:

Returns:



848
 
# File 'lib/wx/doc/gen/gdi_common.rb', line 848

def intersect(rect) end

#intersect!(rect) ⇒ self

Update this rectangle to the intersection with ‘rect’

Parameters:

Returns:

  • (self) 


245
 
# File 'lib/wx/doc/gdi_common.rb', line 245

def intersect!(rect) end

#intersects(rect) ⇒ Boolean

Returns true if this rectangle has a non-empty intersection with the rectangle rect and false otherwise.

Parameters:

Returns:

  • (Boolean) 


853
 
# File 'lib/wx/doc/gen/gdi_common.rb', line 853

def intersects(rect) end

#is_empty ⇒ Boolean Also known as: empty?

Returns true if this rectangle has a width or height less than or equal to 0 and false otherwise.

Returns:

  • (Boolean) 


857
 
# File 'lib/wx/doc/gen/gdi_common.rb', line 857

def is_empty; end

#offset(dx, dy) ⇒ Wx::Rect #offset(pt) ⇒ Wx::Rect

Overloads:

  • #offset(dx, dy) ⇒ Wx::Rect

    Moves the rectangle by the specified offset. If dx is positive, the rectangle is moved to the right, if dy is positive, it is moved to the bottom, otherwise it is moved to the left or top respectively.

    Parameters:

    • dx (Integer)
    • dy (Integer)

    Returns:

  • #offset(pt) ⇒ Wx::Rect

    Moves the rectangle by the specified offset. If dx is positive, the rectangle is moved to the right, if dy is positive, it is moved to the bottom, otherwise it is moved to the left or top respectively.

    Parameters:

    Returns:



304
 
# File 'lib/wx/doc/gdi_common.rb', line 304

def offset(*args) end

#offset!(dx, dy) ⇒ self #offset!(pt) ⇒ self

Overloads:

  • #offset!(dx, dy) ⇒ self

    Moves the rectangle by the specified offset. If dx is positive, the rectangle is moved to the right, if dy is positive, it is moved to the bottom, otherwise it is moved to the left or top respectively.

    Parameters:

    • dx (Integer)
    • dy (Integer)

    Returns:

    • (self)
  • #offset!(pt) ⇒ self

    Moves the rectangle by the specified offset. If dx is positive, the rectangle is moved to the right, if dy is positive, it is moved to the bottom, otherwise it is moved to the left or top respectively.

    Parameters:

    Returns:

    • (self) 


317
 
# File 'lib/wx/doc/gdi_common.rb', line 317

def offset!(*args) end

#set_bottom(bottom) ⇒ void Also known as: bottom=

This method returns an undefined value.

Set the bottom edge of the rectangle.

Notice that this doesn’t affect #get_top return value but changes the rectangle height to set its bottom side to the given position.

Parameters:

  • bottom (Integer) 


928
 
# File 'lib/wx/doc/gen/gdi_common.rb', line 928

def set_bottom(bottom) end

#set_bottom_left(p) ⇒ void Also known as: bottom_left=

This method returns an undefined value.

Set the bottom-left point of the rectangle.

Parameters:



952
 
# File 'lib/wx/doc/gen/gdi_common.rb', line 952

def set_bottom_left(p) end

#set_bottom_right(p) ⇒ void Also known as: bottom_right=

This method returns an undefined value.

Set the bottom-right point of the rectangle.

Parameters:



940
 
# File 'lib/wx/doc/gen/gdi_common.rb', line 940

def set_bottom_right(p) end

#set_height(height) ⇒ void Also known as: height=

This method returns an undefined value.

Sets the height.

Parameters:

  • height (Integer) 


863
 
# File 'lib/wx/doc/gen/gdi_common.rb', line 863

def set_height(height) end

#set_left(left) ⇒ void Also known as: left=

This method returns an undefined value.

Set the left side of the rectangle.

Notice that because the rectangle stores its left side and width, calling #set_left changes the right side position too but does preserve the width.

Parameters:

  • left (Integer) 


904
 
# File 'lib/wx/doc/gen/gdi_common.rb', line 904

def set_left(left) end

#set_position(pos) ⇒ void Also known as: position=

This method returns an undefined value.

Sets the position.

Parameters:



869
 
# File 'lib/wx/doc/gen/gdi_common.rb', line 869

def set_position(pos) end

#set_right(right) ⇒ void Also known as: right=

This method returns an undefined value.

Set the right side of the rectangle.

Notice that this doesn’t affect #get_left return value but changes the rectangle width to set its right side to the given position.

Parameters:

  • right (Integer) 


912
 
# File 'lib/wx/doc/gen/gdi_common.rb', line 912

def set_right(right) end

#set_size(s) ⇒ void Also known as: size=

This method returns an undefined value.

Sets the size.

Parameters:

See Also:



878
 
# File 'lib/wx/doc/gen/gdi_common.rb', line 878

def set_size(s) end

#set_top(top) ⇒ void Also known as: top=

This method returns an undefined value.

Set the top edge of the rectangle.

Notice that because the rectangle stores its top side and height, calling #set_top changes the bottom side position too but does preserve the height.

Parameters:

  • top (Integer) 


920
 
# File 'lib/wx/doc/gen/gdi_common.rb', line 920

def set_top(top) end

#set_top_left(p) ⇒ void Also known as: top_left=

This method returns an undefined value.

Set the top-left point of the rectangle.

Parameters:



934
 
# File 'lib/wx/doc/gen/gdi_common.rb', line 934

def set_top_left(p) end

#set_top_right(p) ⇒ void Also known as: top_right=

This method returns an undefined value.

Set the top-right point of the rectangle.

Parameters:



946
 
# File 'lib/wx/doc/gen/gdi_common.rb', line 946

def set_top_right(p) end

#set_width(width) ⇒ void Also known as: width=

This method returns an undefined value.

Sets the width.

Parameters:

  • width (Integer) 


884
 
# File 'lib/wx/doc/gen/gdi_common.rb', line 884

def set_width(width) end

#set_x(x) ⇒ void Also known as: x=

This method returns an undefined value.

Sets the x position.

Parameters:

  • x (Integer) 


890
 
# File 'lib/wx/doc/gen/gdi_common.rb', line 890

def set_x(x) end

#set_y(y) ⇒ void Also known as: y=

This method returns an undefined value.

Sets the y position.

Parameters:

  • y (Integer) 


896
 
# File 'lib/wx/doc/gen/gdi_common.rb', line 896

def set_y(y) end

#to_ary ⇒ Array(Integer,Integer,Integer,Integer)

Returns rect array ([left, top, width, height])

Returns:

  • (Array(Integer,Integer,Integer,Integer)) —

    rect as array



225
 
# File 'lib/wx/doc/gdi_common.rb', line 225

def to_ary; end

#union(rect) ⇒ Wx::Rect

Modifies the rectangle to contain the bounding box of this rectangle and the one passed in as parameter.

Parameters:

Returns:



725
 
# File 'lib/wx/doc/gen/gdi_common.rb', line 725

def union(rect) end

#union!(rect) ⇒ self

Update this rectangle to the union with ‘rect’

Parameters:

Returns:

  • (self) 


240
 
# File 'lib/wx/doc/gdi_common.rb', line 240

def union!(rect) end

#| ⇒ Object 



321
 
# File 'lib/wx/doc/gdi_common.rb', line 321

alias :| :union