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) 


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

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:

See Also:



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

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:

See Also:



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

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) 


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

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:



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

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) 


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

def get_bottom; end

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

Gets the position of the bottom left corner.

Returns:



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

def get_bottom_left; end

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

Gets the position of the bottom right corner.

Returns:



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

def get_bottom_right; end

#get_height ⇒ Integer Also known as: height

Gets the height member.

Returns:

  • (Integer) 


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

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) 


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

def get_left; end

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

Gets the position.

Returns:



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

def get_position; end

#get_right ⇒ Integer Also known as: right

Gets the right point of the rectangle.

Returns:

  • (Integer) 


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

def get_right; end

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

Gets the size.

Returns:

See Also:



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

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) 


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

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:



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

def get_top_left; end

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

Gets the position of the top right corner.

Returns:



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

def get_top_right; end

#get_width ⇒ Integer Also known as: width

Gets the width member.

Returns:

  • (Integer) 


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

def get_width; end

#get_x ⇒ Integer Also known as: x

Gets the x member.

Returns:

  • (Integer) 


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

def get_x; end

#get_y ⇒ Integer Also known as: y

Gets the y member.

Returns:

  • (Integer) 


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

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:



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

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:



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

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) 


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

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) 


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

def is_empty; end

#make_centered_in(r, dir = Wx::Orientation::BOTH) ⇒ void

This method returns an undefined value.

Center this rectangle inside 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)

See Also:



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

def make_centered_in(r, dir=Wx::Orientation::BOTH) 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) 


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

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:



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

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:



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

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) 


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

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) 


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

def set_left(left) end

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

This method returns an undefined value.

Sets the position.

Parameters:



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

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) 


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

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:



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

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) 


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

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:



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

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:



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

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) 


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

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) 


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

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) 


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

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:



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

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