Struct QRectF 

pub struct QRectF { /* private fields */ }

The QRectF struct defines a rectangle in the plane using floating point precision.

Implementations

impl QRectF

pub fn adjust(&mut self, dx1: f64, dy1: f64, dx2: f64, dy2: f64)

Adds dx1, dy1, dx2 and dy2 respectively to the existing coordinates of the rectangle. All parameters must be finite.

pub fn adjusted(&self, dx1: f64, dy1: f64, dx2: f64, dy2: f64) -> QRectF

Returns a new rectangle with dx1, dy1, dx2 and dy2 added respectively to the existing coordinates of this rectangle. All parameters must be finite.

pub fn bottom(&self) -> f64

Returns the y-coordinate of the rectangle’s bottom edge.

pub fn bottom_left(&self) -> QPointF

Returns the position of the rectangle’s bottom-left corner.

pub fn bottom_right(&self) -> QPointF

Returns the position of the rectangle’s bottom-right corner.

pub fn center(&self) -> QPointF

Returns the center point of the rectangle.

pub fn contains(&self, point: &QPointF) -> bool

Returns true if the given point is inside or on the edge of the rectangle; otherwise returns false.

pub fn height(&self) -> f64

Returns the height of the rectangle.

pub fn intersected(&self, rectangle: &QRectF) -> QRectF

Returns the intersection of this rectangle and the given rectangle. Note that r.intersected(s) is equivalent to r & s.

pub fn intersects(&self, rectangle: &QRectF) -> bool

Returns true if this rectangle intersects with the given rectangle (i.e. there is a non-empty area of overlap between them), otherwise returns false.

pub fn is_empty(&self) -> bool

Returns true if the rectangle is empty, otherwise returns false.

An empty rectangle has width() <= 0 or height() <= 0. An empty rectangle is not valid (i.e., isEmpty() == !isValid()).

pub fn is_null(&self) -> bool

Returns true if the rectangle is a null rectangle, otherwise returns false.

A null rectangle has both the width and the height set to 0. A null rectangle is also empty, and hence not valid.

pub fn is_valid(&self) -> bool

Returns true if the rectangle is valid, otherwise returns false.

A valid rectangle has a width() > 0 and height() > 0. Note that non-trivial operations like intersections are not defined for invalid rectangles. A valid rectangle is not empty (i.e., isValid() == !isEmpty()).

pub fn left(&self) -> f64

Returns the x-coordinate of the rectangle’s left edge. Equivalent to x().

pub fn margins_added(&self, margins: &QMarginsF) -> QRectF

Returns a rectangle grown by the margins.

pub fn margins_removed(&self, margins: &QMarginsF) -> QRectF

Removes the margins from the rectangle, shrinking it.

pub fn move_bottom(&mut self, y: f64)

Moves the rectangle vertically, leaving the rectangle’s bottom edge at the given finite y coordinate. The rectangle’s size is unchanged.

pub fn move_bottom_left(&mut self, position: &QPointF)

Moves the rectangle, leaving the bottom-left corner at the given position. The rectangle’s size is unchanged.

pub fn move_bottom_right(&mut self, position: &QPointF)

Moves the rectangle, leaving the bottom-right corner at the given position. The rectangle’s size is unchanged.

pub fn move_center(&mut self, position: &QPointF)

Moves the rectangle, leaving the center point at the given position. The rectangle’s size is unchanged.

pub fn move_left(&mut self, x: f64)

Moves the rectangle horizontally, leaving the rectangle’s left edge at the given finite x coordinate. The rectangle’s size is unchanged.

pub fn move_right(&mut self, x: f64)

Moves the rectangle horizontally, leaving the rectangle’s right edge at the given finite x coordinate. The rectangle’s size is unchanged.

pub fn move_to(&mut self, position: &QPointF)

Moves the rectangle, leaving the top-left corner at the given position.

pub fn move_top(&mut self, y: f64)

Moves the rectangle vertically, leaving the rectangle’s top line at the given finite y coordinate. The rectangle’s size is unchanged.

pub fn move_top_left(&mut self, position: &QPointF)

Moves the rectangle, leaving the top-left corner at the given position. The rectangle’s size is unchanged.

pub fn move_top_right(&mut self, position: &QPointF)

Moves the rectangle, leaving the top-right corner at the given position. The rectangle’s size is unchanged.

pub fn normalized(&self) -> QRectF

Returns a normalized rectangle; i.e., a rectangle that has a non-negative width and height.

pub fn right(&self) -> f64

Returns the x-coordinate of the rectangle’s right edge.

pub fn set_bottom(&mut self, y: f64)

Sets the bottom edge of the rectangle to the given finite y coordinate. May change the height, but will never change the top edge of the rectangle.

pub fn set_bottom_left(&mut self, position: &QPointF)

Set the bottom-left corner of the rectangle to the given position. May change the size, but will never change the top-right corner of the rectangle.

pub fn set_bottom_right(&mut self, position: &QPointF)

Set the bottom-right corner of the rectangle to the given position. May change the size, but will never change the top-left corner of the rectangle.

pub fn set_coords(&mut self, x1: f64, y1: f64, x2: f64, y2: f64)

Sets the coordinates of the rectangle’s top-left corner to (x1, y1), and the coordinates of its bottom-right corner to (x2, y2). All parameters must be finite.

pub fn set_height(&mut self, h: f64)

Sets the height of the rectangle to the given finite height. The bottom edge is changed, but not the top one.

pub fn set_left(&mut self, x: f64)

Sets the left edge of the rectangle to the given finite x coordinate. May change the width, but will never change the right edge of the rectangle.

pub fn set_rect(&mut self, x: f64, y: f64, width: f64, height: f64)

Sets the coordinates of the rectangle’s top-left corner to (x, y), and its size to the given width and height. All parameters must be finite.

pub fn set_right(&mut self, x: f64)

Sets the right edge of the rectangle to the given finite x coordinate. May change the width, but will never change the left edge of the rectangle.

pub fn set_size(&mut self, size: &QSizeF)

Sets the size of the rectangle to the given finite size. The top-left corner is not moved.

pub fn set_top(&mut self, y: f64)

Sets the top edge of the rectangle to the given finite y coordinate. May change the height, but will never change the bottom edge of the rectangle.

pub fn set_top_left(&mut self, position: &QPointF)

Set the top-left corner of the rectangle to the given position. May change the size, but will never change the bottom-right corner of the rectangle.

pub fn set_top_right(&mut self, position: &QPointF)

Set the top-right corner of the rectangle to the given position. May change the size, but will never change the bottom-left corner of the rectangle.

pub fn set_width(&mut self, w: f64)

Sets the width of the rectangle to the given finite width. The right edge is changed, but not the left one.

pub fn set_x(&mut self, x: f64)

Sets the left edge of the rectangle to the given finite x coordinate. May change the width, but will never change the right edge of the rectangle.

pub fn set_y(&mut self, y: f64)

Sets the top edge of the rectangle to the given finite y coordinate. May change the height, but will never change the bottom edge of the rectangle.

pub fn size(&self) -> QSizeF

Returns the size of the rectangle.

pub fn to_aligned_rect(&self) -> QRect

Returns a QRect based on the values of this rectangle that is the smallest possible integer rectangle that completely contains this rectangle.

pub fn to_rect(&self) -> QRect

Returns a QRect based on the values of this rectangle. Note that the coordinates in the returned rectangle are rounded to the nearest integer.

pub fn top(&self) -> f64

Returns the y-coordinate of the rectangle’s top edge. Equivalent to y().

pub fn top_left(&self) -> QPointF

Returns the position of the rectangle’s top-left corner.

pub fn top_right(&self) -> QPointF

Returns the position of the rectangle’s top-right corner.

pub fn translate(&mut self, offset: &QPointF)

Moves the rectangle offset.x() along the x axis and offset.y() along the y axis, relative to the current position.

pub fn translated(&self, offset: &QPointF) -> QRectF

Returns a copy of the rectangle that is translated offset.x() along the x axis and offset.y() along the y axis, relative to the current position.

pub fn transposed(&self) -> QRectF

Returns a copy of the rectangle that has its width and height exchanged.

pub fn united(&self, rectangle: &QRectF) -> QRectF

Returns the bounding rectangle of this rectangle and the given rectangle.

pub fn width(&self) -> f64

Returns the width of the rectangle.

pub fn x(&self) -> f64

Returns the x-coordinate of the rectangle’s left edge.

pub fn y(&self) -> f64

Returns the y-coordinate of the rectangle’s top edge.

impl QRectF

pub fn new(x: f64, y: f64, width: f64, height: f64) -> Self

Constructs a rectangle with (x, y) as its top-left corner and the given width and height.

Trait Implementations

impl Add<QMarginsF> for QRectF

type Output = QRectF

The resulting type after applying the + operator.

fn add(self, other: QMarginsF) -> Self

Performs the + operation.

impl Clone for QRectF

fn clone(&self) -> QRectF

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for QRectF

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for QRectF

fn default() -> Self

Constructs a null rectangle.

impl Display for QRectF

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl ExternType for QRectF

type Id = (Q, R, e, c, t, F)

A type-level representation of the type’s C++ namespace and type name.

type Kind = Trivial

Either cxx::kind::Opaque or cxx::kind::Trivial.

impl From<&QRect> for QRectF

fn from(rectangle: &QRect) -> Self

Constructs a QRectF rectangle from the given QRect rectangle.

impl From<&QRectF> for QRect

fn from(value: &QRectF) -> Self

Returns a QRect based on the values of this rectangle. Note that the coordinates in the returned rectangle are rounded to the nearest integer.

impl PartialEq for QRectF

fn eq(&self, other: &QRectF) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl QListElement for QRectF

type TypeId = (Q, L, i, s, t, __, Q, R, e, c, t, F)

fn append(list: &mut QList<Self>, value: Self)

fn append_clone(list: &mut QList<Self>, value: &Self)

fn clear(list: &mut QList<Self>)

fn clone(list: &QList<Self>) -> QList<Self>

fn contains(list: &QList<Self>, value: &Self) -> bool

fn default() -> QList<Self>

fn drop(list: &mut QList<Self>)

unsafe fn get_unchecked(list: &QList<Self>, pos: isize) -> &Self

Safety

fn index_of(list: &QList<Self>, value: &Self) -> isize

fn insert(list: &mut QList<Self>, pos: isize, value: Self)

fn insert_clone(list: &mut QList<Self>, pos: isize, value: &Self)

fn len(list: &QList<Self>) -> isize

fn remove(list: &mut QList<Self>, pos: isize)

fn reserve(list: &mut QList<Self>, size: isize)

impl QVariantValue for QRectF

fn can_convert(variant: &QVariant) -> bool

fn construct(value: &Self) -> QVariant

fn value_or_default(variant: &QVariant) -> Self

impl QVectorElement for QRectF

type TypeId = (Q, V, e, c, t, o, r, __, Q, R, e, c, t, F)

fn append(vector: &mut QVector<Self>, value: Self)

fn append_clone(vector: &mut QVector<Self>, value: &Self)

fn clear(vector: &mut QVector<Self>)

fn clone(vector: &QVector<Self>) -> QVector<Self>

fn contains(vector: &QVector<Self>, value: &Self) -> bool

fn default() -> QVector<Self>

fn drop(vector: &mut QVector<Self>)

unsafe fn get_unchecked(vector: &QVector<Self>, pos: isize) -> &Self

Safety

fn index_of(vector: &QVector<Self>, value: &Self) -> isize

fn insert(vector: &mut QVector<Self>, pos: isize, value: Self)

fn insert_clone(vector: &mut QVector<Self>, pos: isize, value: &Self)

fn len(vector: &QVector<Self>) -> isize

fn remove(vector: &mut QVector<Self>, pos: isize)

fn reserve(vector: &mut QVector<Self>, size: isize)

impl Sub<QMarginsF> for QRectF

type Output = QRectF

The resulting type after applying the - operator.

fn sub(self, other: QMarginsF) -> Self

Performs the - operation.

impl StructuralPartialEq for QRectF