Rect Structure

Référence

Définition

Espace de noms:: System.Windows

Assembly:: WindowsBase.dll

Important

Certaines informations portent sur la préversion du produit qui est susceptible d’être en grande partie modifiée avant sa publication. Microsoft exclut toute garantie, expresse ou implicite, concernant les informations fournies ici.

Décrit la largeur, la hauteur et l’emplacement d’un rectangle.

public value class Rect : IFormattable

[System.ComponentModel.TypeConverter(typeof(System.Windows.RectConverter))]
[System.Serializable]
public struct Rect : IFormattable

[System.ComponentModel.TypeConverter(typeof(System.Windows.RectConverter))]
public struct Rect : IFormattable

[<System.ComponentModel.TypeConverter(typeof(System.Windows.RectConverter))>]
[<System.Serializable>]
type Rect = struct
    interface IFormattable

[<System.ComponentModel.TypeConverter(typeof(System.Windows.RectConverter))>]
type Rect = struct
    interface IFormattable

Public Structure Rect
Implements IFormattable

Héritage: Object

ValueType
Rect

Attributs: TypeConverterAttribute SerializableAttribute

Implémente: IFormattable

Exemples

L’exemple suivant montre comment utiliser une Rect structure pour spécifier les dimensions et l’emplacement d’un rectangle à l’aide de XAML.

using System;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Media;
using System.Windows.Shapes;

namespace SDKSample
{
    public partial class RectExample : Page
    {
        public RectExample()
        {   
            Path myPath1 = new Path();
            myPath1.Stroke = Brushes.Black;
            myPath1.StrokeThickness = 1;
            SolidColorBrush mySolidColorBrush = new SolidColorBrush();
            mySolidColorBrush.Color = Color.FromArgb(255, 204, 204, 255);
            myPath1.Fill = mySolidColorBrush;

            // Create the rectangle.
            // This RectangleGeometry specifies a rectangle that is 100 pixels high and
            // 150 wide. The left side of the rectangle is 10 pixels from the left of the 
            // Canvas and the top side of the rectangle is 100 pixels from the top of the Canvas.  
            // Note: You could alternatively use the Rect Constructor to create this:
            // Rect my Rect1 = new Rect(10,100,150,100");
            Rect myRect1 = new Rect();
            myRect1.X = 10;
            myRect1.Y = 100;
            myRect1.Width = 150;
            myRect1.Height = 100;
            RectangleGeometry myRectangleGeometry1 = new RectangleGeometry();
            myRectangleGeometry1.Rect = myRect1;

            GeometryGroup myGeometryGroup1 = new GeometryGroup();
            myGeometryGroup1.Children.Add(myRectangleGeometry1);

            myPath1.Data = myGeometryGroup1;

            Path myPath2 = new Path();
            myPath2.Stroke = Brushes.Black;
            myPath2.StrokeThickness = 1;
            myPath2.Fill = mySolidColorBrush;

            // Create the rectangle.
            // This Rect uses the Size property to specify a height of 50 and width
            // of 200. The Location property uses a Point value to determine the location of the
            // top-left corner of the rectangle.
            Rect myRect2 = new Rect();
            myRect2.Size = new Size(50, 200);
            myRect2.Location = new Point(300, 100);
            RectangleGeometry myRectangleGeometry2 = new RectangleGeometry();
            myRectangleGeometry2.Rect = myRect2;

            GeometryGroup myGeometryGroup2 = new GeometryGroup();
            myGeometryGroup2.Children.Add(myRectangleGeometry2);

            myPath2.Data = myGeometryGroup2;

            // Add path shape to the UI.
            Canvas myCanvas = new Canvas();
            myCanvas.Children.Add(myPath1);
            myCanvas.Children.Add(myPath2);
            this.Content = myCanvas;       
        }
    }
}


Imports System.Windows
Imports System.Windows.Controls
Imports System.Windows.Media
Imports System.Windows.Shapes

Namespace SDKSample
    Partial Public Class RectExample
        Inherits Page
        Public Sub New()
            Dim myPath1 As New Path()
            myPath1.Stroke = Brushes.Black
            myPath1.StrokeThickness = 1
            Dim mySolidColorBrush As New SolidColorBrush()
            mySolidColorBrush.Color = Color.FromArgb(255, 204, 204, 255)
            myPath1.Fill = mySolidColorBrush

            ' Create the rectangle.
            ' This RectangleGeometry specifies a rectangle that is 100 pixels high and
            ' 150 wide. The left side of the rectangle is 10 pixels from the left of the 
            ' Canvas and the top side of the rectangle is 100 pixels from the top of the Canvas.  
            ' Note: You could alternatively use the Rect Constructor to create this:
            ' Dim myRect1 As New Rect(10,100,150,100")
            Dim myRect1 As New Rect()
            myRect1.X = 10
            myRect1.Y = 100
            myRect1.Width = 150
            myRect1.Height = 100
            Dim myRectangleGeometry1 As New RectangleGeometry()
            myRectangleGeometry1.Rect = myRect1

            Dim myGeometryGroup1 As New GeometryGroup()
            myGeometryGroup1.Children.Add(myRectangleGeometry1)

            myPath1.Data = myGeometryGroup1

            Dim myPath2 As New Path()
            myPath2.Stroke = Brushes.Black
            myPath2.StrokeThickness = 1
            myPath2.Fill = mySolidColorBrush

            ' Create the rectangle.
            ' This Rect uses the Size property to specify a height of 50 and width
            ' of 200. The Location property uses a Point value to determine the location of the
            ' top-left corner of the rectangle.
            Dim myRect2 As New Rect()
            myRect2.Size = New Size(50, 200)
            myRect2.Location = New Point(300, 100)
            Dim myRectangleGeometry2 As New RectangleGeometry()
            myRectangleGeometry2.Rect = myRect2

            Dim myGeometryGroup2 As New GeometryGroup()
            myGeometryGroup2.Children.Add(myRectangleGeometry2)

            myPath2.Data = myGeometryGroup2

            ' Add path shape to the UI.
            Dim myCanvas As New Canvas()
            myCanvas.Children.Add(myPath1)
            myCanvas.Children.Add(myPath2)
            Me.Content = myCanvas
        End Sub
    End Class

End Namespace

<Page  xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
  xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">
  <Canvas>
    
    <!-- This rectangle demonstrates using the X, Y, Width, and Height properties
         of a Rect object. -->
    <Path Stroke="Black" StrokeThickness="1" Fill="LemonChiffon">
      <Path.Data>

        <!-- This RectangleGeometry specifies a rectangle that is 100 pixels high and
             150 wide. The left side of the rectangle is 10 pixels from the left of the 
             Canvas and the top side of the rectangle is 100 pixels from the top of the Canvas.  
             Note: An abbreviated syntax for creating an equivalent rectangle is:
             <RectangleGeometry Rect="10,100,150,100" /> -->
        <RectangleGeometry>
          <RectangleGeometry.Rect>
            <Rect X="10" Y="100" Width="150" Height="100" />
          </RectangleGeometry.Rect>
        </RectangleGeometry>
      </Path.Data>
    </Path>

    <!-- This rectangle demonstrates using the Size and Location properties of a Rect object. -->
    <Path Stroke="Black" StrokeThickness="1" Fill="LemonChiffon">
      <Path.Data>

        <!-- This RectangleGeometry uses the Size property to specify a height of 50 and width
             of 200. The Location property uses a Point value to determine the location of the
             top-left corner of the rectangle. /> -->
        <RectangleGeometry>
          <RectangleGeometry.Rect>
            <Rect Size="50,200" Location="300,100" />
          </RectangleGeometry.Rect>
        </RectangleGeometry>
      </Path.Data>
    </Path>
  </Canvas>
</Page>

L’exemple suivant montre comment utiliser le code pour créer un rectangle et l’ajouter à la page. L’exemple montre également comment rechercher des informations de taille et de coordonnées sur le nouveau rectangle et afficher les informations dans un TextBox rectangle sous le rectangle.

// Create a rectangle and add it to the page. Also,
// find size and coordinate information about this
// new rectangle and render information in a TextBox 
// below the rectangle.
private StackPanel createRectExample1()
{
    // Initialize new rectangle.
    Rect myRectangle = new Rect();

    // The Location property specifies the coordinates of the upper left-hand 
    // corner of the rectangle. Set the Location property to an X coordinate of 10 and a
    // Y coordinate of 5. 
    myRectangle.Location = new Point(10, 5);

    // Set the Size property of the rectangle with a width of 200
    // and a height of 50.
    myRectangle.Size = new Size(200, 50);

    RectangleGeometry myRectangleGeometry = new RectangleGeometry();
    myRectangleGeometry.Rect = myRectangle;

    // This path is defined by the rectangle.
    Path myPath = new Path();
    myPath.Fill = Brushes.LemonChiffon;
    myPath.Stroke = Brushes.Black;
    myPath.StrokeThickness = 1;
    myPath.Data = myRectangleGeometry;

    //////////// Create string of rectangle property information /////////////
    // This string will contain all the size and coordinate property
    // information about the rectangle.
    /////////////////////////////////////////////////////////////////////////
    string rectInfo = "Rectangle Property Information: ";

    // Bottom property gets the y-axis value of the bottom of the rectangle. 
    // For this rectangle the value is 55.
    rectInfo = rectInfo + "Bottom: " + myRectangle.Bottom;

    // BottomLeft property gets the coordinates of the bottom left corner of the rectangle. 
    // For this rectangle the value is 10,55.
    rectInfo = rectInfo + "| BottomLeft: " + myRectangle.BottomLeft;

    // BottomRight property gets the coordinates of the bottom right corner of the rectangle. 
    // For this rectangle the value is 210,55.
    rectInfo = rectInfo + "| BottomRight: " + myRectangle.BottomRight;

    // Height property gets or sets the height of the rectangle. 
    // For this rectangle the value is 50.
    rectInfo = rectInfo + "| Height: " + myRectangle.Height;

    // Width property gets or sets the width of the rectangle. 
    // For this rectangle the value is 200.
    rectInfo = rectInfo + "| Width: " + myRectangle.Width;

    // Left property gets the x-axis position of the left side of the rectangle which is 
    // equivalent to getting the rectangle's X property. 
    // For this rectangle the value is 10.
    rectInfo = rectInfo + "| Left: " + myRectangle.Left;

    // Location property gets or sets the position of the rectangle's top-left corner.
    // For this rectangle the value is 10,5.
    rectInfo = rectInfo + "| Location: " + myRectangle.Location;

    // Right property gets the x-axis value of the right side of the rectangle. 
    // For this rectangle the value is 210.
    rectInfo = rectInfo + "| Right: " + myRectangle.Right;

    // Size property gets or sets the width and height of the rectangle.  
    // For this rectangle the value is 200,50.
    rectInfo = rectInfo + "| Size: " + myRectangle.Size;

    // Top property gets the y-axis position of the top of the rectangle which is 
    // equivalent to getting the rectangle's Y property.
    // For this rectangle the value is 5.
    rectInfo = rectInfo + "| Top: " + myRectangle.Top;

    // TopLeft property gets the position of the top-left corner of the rectangle, which 
    // is equivalent to (X, Y).   
    // For this rectangle the value is 10,5.
    rectInfo = rectInfo + "| TopLeft: " + myRectangle.TopLeft;

    // TopRight property gets the position of the top-left corner of the rectangle, which 
    // is equivalent to (X + Width, Y).   
    // For this rectangle the value is 210,5.
    rectInfo = rectInfo + "| TopRight: " + myRectangle.TopRight;

    // X property gets or sets the location of the rectangle's left side.  
    // For this rectangle the value is 10.
    rectInfo = rectInfo + "| X: " + myRectangle.X;

    // Y property gets or sets the location of the rectangle's top side.  
    // For this rectangle the value is 5.
    rectInfo = rectInfo + "| Y: " + myRectangle.Y;

    //////// End of creating string containing rectangle property information ////////

    // This StackPanel will contain the rectangle and TextBlock.
    StackPanel parentPanel = new StackPanel();

    // Add the rectangle path to the StackPanel. This will display the rectangle.
    parentPanel.Children.Add(myPath);

    // Add a TextBlock to display the rectangle's size and coordinate information.
    TextBlock myTextBlock = new TextBlock();
    myTextBlock.Text = rectInfo;
    parentPanel.Children.Add(myTextBlock);

    // Return the parent container to be displayed to the screen.
    return parentPanel;
}

Remarques

Utilisation d'attributs XAML

<object property="x,y,width,height"/>

Valeurs XAML

x
System.Double

Emplacement des coordonnées x du côté gauche du rectangle.

y
System.Double

Emplacement des coordonnées y du côté supérieur du rectangle.

width
System.Double

Valeur non négative qui représente le Width rectangle.

height
System.Double

Valeur non négative qui représente le Height rectangle.

Constructeurs

Rect(Double, Double, Double, Double)	Initialise une nouvelle instance de la structure Rect qui a les coordonnées x et y, et la largeur et la hauteur spécifiées.
Rect(Point, Point)	Initialise une nouvelle instance de la structure Rect qui est exactement assez grande pour contenir les deux points spécifiés.
Rect(Point, Size)	Initialise une nouvelle instance de la structure Rect qui a l'emplacement de coin supérieur gauche, et la largeur et la hauteur spécifiés.
Rect(Point, Vector)	Initialise une nouvelle instance de la structure Rect qui est exactement assez grande pour contenir le point spécifié et la somme du point et du vecteur spécifiés.
Rect(Size)	Initialise une nouvelle instance de la structure Rect qui fait la taille spécifiée et est localisée à (0,0).

Propriétés

Bottom	Obtient la valeur d'axe y du bas du rectangle.
BottomLeft	Obtient la position du coin inférieur gauche du rectangle.
BottomRight	Obtient la position du coin inférieur droit du rectangle
Empty	Obtient une valeur spéciale qui représente un rectangle sans position ou zone.
Height	Obtient ou définit la hauteur du rectangle.
IsEmpty	Obtient une valeur qui indique si le rectangle est le rectangle Empty.
Left	Obtient la valeur d'axe x du côté gauche du rectangle.
Location	Obtient ou définit la position de l'angle supérieur gauche du rectangle.
Right	Obtient la valeur d'axe x du côté droit du rectangle.
Size	Obtient ou définit la largeur et la hauteur du rectangle.
Top	Obtient la position de l'axe y du haut du rectangle.
TopLeft	Obtient la position du coin supérieur gauche du rectangle.
TopRight	Obtient la position du coin supérieur droit du rectangle.
Width	Obtient ou définit la largeur du rectangle.
X	Obtient ou définit la valeur d'axe x du côté gauche du rectangle.
Y	Obtient ou définit la valeur d'axe y du côté supérieur du rectangle.

Méthodes

Contains(Double, Double)	Indique si le rectangle contient les coordonnées x et y spécifiées.
Contains(Point)	Indique si le rectangle contient le point spécifié.
Contains(Rect)	Indique si le rectangle contient le rectangle spécifié.
Equals(Object)	Détermine si l'objet spécifié est égal au rectangle actuel.
Equals(Rect)	Indique si le rectangle spécifié est égal au rectangle actuel.
Equals(Rect, Rect)	Indique si les rectangles spécifiés sont égaux.
GetHashCode()	Crée un code de hachage pour le rectangle.
Inflate(Double, Double)	Développe ou réduit le rectangle en utilisant les taux de largeur et de hauteur spécifiés, dans toutes les directions.
Inflate(Rect, Double, Double)	Crée un rectangle qui résulte du développement ou de la réduction du rectangle spécifié par les taux de largeur ou de hauteur spécifiés, dans toutes les directions.
Inflate(Rect, Size)	Renvoie le rectangle qui résulte du développement du rectangle spécifié par la Sizespécifiée, dans toutes les directions.
Inflate(Size)	Développe le rectangle en utilisant la Sizespécifiée, dans toutes les directions.
Intersect(Rect)	Trouve l'intersection du rectangle actuel et du rectangle spécifié, et stocke le résultat comme le rectangle actuel.
Intersect(Rect, Rect)	Renvoie l'intersection des rectangles spécifiés.
IntersectsWith(Rect)	Indique si le rectangle spécifié se croise avec le rectangle actuel.
Offset(Double, Double)	Déplace le rectangle par les taux horizontal et vertical spécifiés.
Offset(Rect, Double, Double)	Renvoie un rectangle qui est décalé du rectangle spécifié en utilisant les taux horizontal et vertical spécifiés.
Offset(Rect, Vector)	Renvoie un rectangle qui est décalé du rectangle spécifié en utilisant le vecteur spécifié.
Offset(Vector)	Déplace le rectangle par le vecteur spécifié.
Parse(String)	Crée un nouveau rectangle à partir de la représentation sous forme de chaîne spécifiée.
Scale(Double, Double)	Multiplie la taille du rectangle actuel par les valeurs x et y spécifiées.
ToString()	Renvoie une représentation sous forme de chaîne du rectangle.
ToString(IFormatProvider)	Renvoie une représentation sous forme de chaîne du rectangle en utilisant le fournisseur de format spécifié.
Transform(Matrix)	Transforme le rectangle en appliquant la matrice spécifiée.
Transform(Rect, Matrix)	Renvoie le rectangle qui résulte de l'application de la matrice spécifiée au rectangle spécifié.
Union(Point)	Développe le rectangle actuel exactement assez pour contenir le point spécifié.
Union(Rect)	Développe le rectangle actuel exactement assez pour contenir le rectangle spécifié.
Union(Rect, Point)	Crée un rectangle qui est exactement assez grand pour inclure le rectangle et le point spécifiés.
Union(Rect, Rect)	Crée un rectangle qui est exactement assez grand pour contenir les deux rectangles spécifiés.

Opérateurs

Equality(Rect, Rect)	Compare l'égalité exacte de deux rectangles.
Inequality(Rect, Rect)	Compare si deux rectangles sont inégaux.

Implémentations d’interfaces explicites

IFormattable.ToString(String, IFormatProvider)

Met en forme la valeur de l’instance actuelle en utilisant le format spécifié.

S’applique à