CRgn, classe

  • Article

Encapsule une région GDI (Graphics Device Interface) Windows.

Syntaxe

class CRgn : public CGdiObject

Membres

Constructeurs publics

Nom Description
CRgn ::CRgn Construit un objet CRgn.

Méthodes publiques

Nom Description
CRgn ::CombineRgn Définit un CRgn objet afin qu’il soit équivalent à l’union de deux objets spécifiés CRgn .
CRgn ::CopyRgn Définit un CRgn objet afin qu’il soit une copie d’un objet spécifié CRgn .
CRgn ::CreateEllipticRgn Initialise un CRgn objet avec une région elliptique.
CRgn ::CreateEllipticRgnIndirect Initialise un CRgn objet avec une région elliptique définie par une structure RECT .
CRgn ::CreateFromData Crée une région à partir de la région donnée et des données de transformation.
CRgn ::CreateFromPath Crée une région à partir du chemin d’accès sélectionné dans le contexte d’appareil donné.
CRgn ::CreatePolygonRgn Initialise un CRgn objet avec une région polygonale. Le système ferme automatiquement le polygone, si nécessaire, en dessinant une ligne du dernier sommet au premier.
CRgn ::CreatePolyPolygonRgn Initialise un CRgn objet avec une région composée d’une série de polygones fermés. Les polygones peuvent être disjoints, ou ils peuvent se chevaucher.
CRgn ::CreateRectRgn Initialise un CRgn objet avec une région rectangulaire.
CRgn ::CreateRectRgnIndirect Initialise un CRgn objet avec une région rectangulaire définie par une trêve RECT.
CRgn ::CreateRoundRectRgn Initialise un CRgn objet avec une région rectangulaire avec des angles arrondis.
CRgn ::EqualRgn Vérifie deux CRgn objets pour déterminer s’ils sont équivalents.
CRgn ::FromHandle Retourne un pointeur vers un CRgn objet lorsqu’un handle est donné à une région Windows.
CRgn ::GetRegionData Remplit la mémoire tampon spécifiée avec des données décrivant la région donnée.
CRgn ::GetRgnBox Récupère les coordonnées du rectangle englobant d’un CRgn objet.
CRgn ::OffsetRgn Déplace un CRgn objet par les décalages spécifiés.
CRgn ::P tInRegion Détermine si un point spécifié se trouve dans la région.
CRgn ::RectInRegion Détermine si une partie d’un rectangle spécifié se trouve dans les limites de la région.
CRgn ::SetRectRgn Définit l’objet CRgn sur la région rectangulaire spécifiée.

Opérateurs publics

Nom Description
CRgn ::operator HRGN Retourne le handle Windows contenu dans l’objet CRgn .

Notes

Une région est une zone elliptique ou polygonale dans une fenêtre. Pour utiliser des régions, vous utilisez les fonctions membres de classe CRgn avec les fonctions de découpage définies en tant que membres de la classe CDC.

Fonctions membres de la création, de la modification et de CRgn la récupération d’informations sur l’objet de région pour lequel elles sont appelées.

Pour plus d’informations sur l’utilisation CRgn, consultez Objets graphiques.

Hiérarchie d'héritage

CObject

CGdiObject

CRgn

Spécifications

En-tête : afxwin.h

CRgn ::CombineRgn

Crée une région GDI en combinant deux régions existantes.

int CombineRgn(
    CRgn* pRgn1,
    CRgn* pRgn2,
    int nCombineMode);

Paramètres

pRgn1
Identifie une région existante.

pRgn2
Identifie une région existante.

nCombineMode
Spécifie l’opération à effectuer lors de la combinaison des deux régions sources. Il peut s’agir de l’une des valeurs suivantes :

  • RGN_AND Utilise des zones qui se chevauchent dans les deux régions (intersection).

  • RGN_COPY Crée une copie de la région 1 (identifiée par pRgn1).

  • RGN_DIFF Crée une région composée des zones de la région 1 (identifiées par pRgn1) qui ne font pas partie de la région 2 (identifiées par pRgn2).

  • RGN_OR Combine les deux régions dans leur intégralité (union).

  • RGN_XOR Combine les deux régions, mais supprime les zones qui se chevauchent.

Valeur de retour

Spécifie le type de la région résultante. Ce peut être l’une des valeurs suivantes :

  • COMPLEXREGION New region a des bordures qui se chevauchent.

  • ERREUR Aucune nouvelle région n’a été créée.

  • NULLREGION New region is empty.

  • SIMPLEREGION New region n’a pas de bordures qui se chevauchent.

Notes

Les régions sont combinées comme spécifié par nCombineMode.

Les deux régions spécifiées sont combinées et le handle de région résultant est stocké dans l’objet CRgn . Par conséquent, quelle que soit la région stockée dans l’objet CRgn , elle est remplacée par la région combinée.

La taille d’une région est limitée à 32 767 par 32 767 unités logiques ou 64 Ko de mémoire, selon ce qui est plus petit.

Utilisez CopyRgn pour simplement copier une région dans une autre région.

Exemple

CRgn   rgnA, rgnB, rgnC;

VERIFY(rgnA.CreateRectRgn(50, 50, 150, 150));
VERIFY(rgnB.CreateRectRgn(100, 100, 200, 200));
VERIFY(rgnC.CreateRectRgn(0, 0, 50, 50));

int nCombineResult = rgnC.CombineRgn(&rgnA, &rgnB, RGN_OR);
ASSERT(nCombineResult != ERROR && nCombineResult != NULLREGION);

CBrush br1, br2, br3;
VERIFY(br1.CreateSolidBrush(RGB(255, 0, 0)));  // rgnA Red
VERIFY(pDC->FrameRgn(&rgnA, &br1, 2, 2));
VERIFY(br2.CreateSolidBrush(RGB(0, 255, 0)));  // rgnB Green
VERIFY(pDC->FrameRgn(&rgnB, &br2, 2, 2));
VERIFY(br3.CreateSolidBrush(RGB(0, 0, 255)));  // rgnC Blue
VERIFY(pDC->FrameRgn(&rgnC, &br3, 2, 2));

CRgn ::CopyRgn

Copie la région définie par pRgnSrc dans l’objet CRgn .

int CopyRgn(CRgn* pRgnSrc);

Paramètres

pRgnSrc
Identifie une région existante.

Valeur de retour

Spécifie le type de la région résultante. Ce peut être l’une des valeurs suivantes :

  • COMPLEXREGION New region a des bordures qui se chevauchent.

  • ERREUR Aucune nouvelle région n’a été créée.

  • NULLREGION New region is empty.

  • SIMPLEREGION New region n’a pas de bordures qui se chevauchent.

Notes

La nouvelle région remplace la région précédemment stockée dans l’objet CRgn . Cette fonction est un cas spécial de la fonction membre CombineRgn .

Exemple

Consultez l’exemple de CRgn ::CreateEllipticRgn.

CRgn ::CreateEllipticRgn

Crée une région elliptique.

BOOL CreateEllipticRgn(
    int x1,
    int y1,
    int x2,
    int y2);

Paramètres

x1
Spécifie la coordonnée x logique du coin supérieur gauche du rectangle englobant de l’ellipse.

y1
Spécifie la coordonnée y logique du coin supérieur gauche du rectangle englobant de l’ellipse.

x2
Spécifie la coordonnée x logique du coin inférieur droit du rectangle englobant de l’ellipse.

y2
Spécifie la coordonnée y logique du coin inférieur droit du rectangle englobant de l’ellipse.

Valeur de retour

Différent de zéro si l’opération a réussi ; sinon 0.

Notes

La région est définie par le rectangle englobant spécifié par x1, y1, x2 et y2. La région est stockée dans l’objet CRgn .

La taille d’une région est limitée à 32 767 par 32 767 unités logiques ou 64 Ko de mémoire, selon ce qui est plus petit.

Une fois qu’elle a fini d’utiliser une région créée avec la CreateEllipticRgn fonction, une application doit sélectionner la région hors du contexte de l’appareil et utiliser la fonction pour la DeleteObject supprimer.

Exemple

CRgn   rgnA, rgnB, rgnC;

VERIFY(rgnA.CreateEllipticRgn(200, 100, 350, 250));
VERIFY(rgnB.CreateRectRgn(0, 0, 50, 50));
VERIFY(rgnB.CopyRgn(&rgnA));
int nOffsetResult = rgnB.OffsetRgn(-75, 75);
ASSERT(nOffsetResult != ERROR && nOffsetResult != NULLREGION);

VERIFY(rgnC.CreateRectRgn(0, 0, 1, 1));
int nCombineResult = rgnC.CombineRgn(&rgnA, &rgnB, RGN_AND);
ASSERT(nCombineResult != ERROR && nOffsetResult != NULLREGION);

CBrush brA, brB, brC;
VERIFY(brC.CreateHatchBrush(HS_FDIAGONAL, RGB(0, 0, 255))); // Blue
VERIFY(pDC->FillRgn(&rgnC, &brC));
VERIFY(brA.CreateSolidBrush(RGB(255, 0, 0)));  // rgnA Red
VERIFY(pDC->FrameRgn(&rgnA, &brA, 2, 2));
VERIFY(brB.CreateSolidBrush(RGB(0, 255, 0)));  // rgnB Green
VERIFY(pDC->FrameRgn(&rgnB, &brB, 2, 2));

CRgn ::CreateEllipticRgnIndirect

Crée une région elliptique.

BOOL CreateEllipticRgnIndirect(LPCRECT lpRect);

Paramètres

lpRect
Pointe vers une RECT structure ou un CRect objet qui contient les coordonnées logiques des coins supérieur gauche et inférieur droit du rectangle englobant de l’ellipse.

Valeur de retour

Différent de zéro si l’opération a réussi ; sinon 0.

Notes

La région est définie par la structure ou l’objet pointé par lpRect et est stocké dans l’objet CRgn .

La taille d’une région est limitée à 32 767 par 32 767 unités logiques ou 64 Ko de mémoire, selon ce qui est plus petit.

Une fois qu’elle a fini d’utiliser une région créée avec la CreateEllipticRgnIndirect fonction, une application doit sélectionner la région hors du contexte de l’appareil et utiliser la fonction pour la DeleteObject supprimer.

Exemple

Consultez l’exemple de CRgn ::CreateRectRgnIndirect.

CRgn ::CreateFromData

Crée une région à partir de la région donnée et des données de transformation.

BOOL CreateFromData(
    const XFORM* lpXForm,
    int nCount,
    const RGNDATA* pRgnData);

Paramètres

lpXForm
Pointe vers une structure ata XFORMqui définit la transformation à effectuer sur la région. Si ce pointeur a la valeur NULL, la transformation d’identité est utilisée.

nCount
Spécifie le nombre d’octets pointés par pRgnData.

pRgnData
Pointe vers une structure de données RGNDATA qui contient les données de région.

Valeur de retour

Une valeur différente de zéro si la fonction réussit ; sinon, 0.

Notes

Une application peut récupérer des données pour une région en appelant la CRgn::GetRegionData fonction.

CRgn ::CreateFromPath

Crée une région à partir du chemin d’accès sélectionné dans le contexte d’appareil donné.

BOOL CreateFromPath(CDC* pDC);

Paramètres

pDC
Identifie un contexte d’appareil qui contient un chemin fermé.

Valeur de retour

Une valeur différente de zéro si la fonction réussit ; sinon, 0.

Notes

Le contexte de l’appareil identifié par le paramètre pDC doit contenir un chemin fermé. Après CreateFromPath avoir converti un chemin d’accès en région, Windows ignore le chemin fermé à partir du contexte de l’appareil.

CRgn ::CreatePolygonRgn

Crée une région polygonale.

BOOL CreatePolygonRgn(
    LPPOINT lpPoints,
    int nCount,
    int nMode);

Paramètres

lpPoints
Pointe vers un tableau de POINT structures ou un tableau d’objets CPoint . Chaque structure spécifie la coordonnée x et la coordonnée y d’un sommet du polygone. La POINT structure a la forme suivante :

typedef struct tagPOINT {
    int x;
    int y;
} POINT;

nCount
Spécifie le nombre de structures ou d’objets POINT dans le tableau pointé par lpPoints.CPoint

nMode
Spécifie le mode de remplissage de la région. Ce paramètre peut être ALTERNATE ou WINDING.

Valeur de retour

Différent de zéro si l’opération a réussi ; sinon 0.

Notes

Le système ferme automatiquement le polygone, si nécessaire, en dessinant une ligne du dernier sommet au premier. La région résultante est stockée dans l’objet CRgn .

La taille d’une région est limitée à 32 767 par 32 767 unités logiques ou 64 Ko de mémoire, selon ce qui est plus petit.

Lorsque le mode de remplissage de polygones est ALTERNATE, le système remplit la zone entre les côtés impairs et pairs des polygones sur chaque ligne d’analyse. Autrement dit, le système remplit la zone entre le premier et le deuxième côté, entre le troisième et le quatrième côté, et ainsi de suite.

Lorsque le mode de remplissage de polygones est WINDING, le système utilise la direction dans laquelle une figure a été dessinée pour déterminer s’il faut remplir une zone. Chaque segment de ligne d’un polygone est dessiné dans le sens des aiguilles d’une montre ou dans un sens inverse. Chaque fois qu’une ligne imaginaire dessinée d’une zone fermée à l’extérieur d’une figure passe par un segment de ligne au niveau des aiguilles d’une montre, un nombre est incrémenté. Lorsque la ligne passe par un segment de ligne dans le sens inverse, le nombre est décrémenté. La zone est remplie si le nombre est différent de zéro lorsque la ligne atteint l’extérieur de la figure.

Lorsqu’une application a terminé d’utiliser une région créée avec la CreatePolygonRgn fonction, elle doit sélectionner la région hors du contexte de l’appareil et utiliser la fonction pour la DeleteObject supprimer.

Exemple

CRgn   rgnA, rgnB;

CPoint ptVertex[5];

ptVertex[0].x = 180;
ptVertex[0].y = 80;
ptVertex[1].x = 100;
ptVertex[1].y = 160;
ptVertex[2].x = 120;
ptVertex[2].y = 260;
ptVertex[3].x = 240;
ptVertex[3].y = 260;
ptVertex[4].x = 260;
ptVertex[4].y = 160;

VERIFY(rgnA.CreatePolygonRgn(ptVertex, 5, ALTERNATE));

CRect rectRgnBox;
int nRgnBoxResult = rgnA.GetRgnBox(&rectRgnBox);
ASSERT(nRgnBoxResult != ERROR && nRgnBoxResult != NULLREGION);

CBrush brA, brB;
VERIFY(brA.CreateSolidBrush(RGB(255, 0, 0)));  // rgnA Red
VERIFY(pDC->FrameRgn(&rgnA, &brA, 2, 2));
VERIFY(brB.CreateSolidBrush(RGB(0, 0, 255)));  // Blue
rectRgnBox.InflateRect(3, 3);
pDC->FrameRect(&rectRgnBox, &brB);

CRgn ::CreatePolyPolygonRgn

Crée une région composée d’une série de polygones fermés.

BOOL CreatePolyPolygonRgn(
    LPPOINT lpPoints,
    LPINT lpPolyCounts,
    int nCount,
    int nPolyFillMode);

Paramètres

lpPoints
Pointe vers un tableau de POINT structures ou un tableau d’objets CPoint qui définit les sommets des polygones. Chaque polygone doit être explicitement fermé, car le système ne les ferme pas automatiquement. Les polygones sont spécifiés consécutivement. La POINT structure a la forme suivante :

typedef struct tagPOINT {
    int x;
    int y;
} POINT;

lpPolyCounts
Pointe vers un tableau d’entiers. Le premier entier spécifie le nombre de sommets dans le premier polygone du tableau lpPoints , le deuxième entier spécifie le nombre de sommets dans le deuxième polygone, et ainsi de suite.

nCount
Spécifie le nombre total d’entiers dans le tableau lpPolyCounts .

nPolyFillMode
Spécifie le mode de remplissage de polygones. Cette valeur peut être ALTER OU WINDING.

Valeur de retour

Différent de zéro si l’opération a réussi ; sinon 0.

Notes

La région résultante est stockée dans l’objet CRgn .

Les polygones peuvent être disjoints, ou ils peuvent se chevaucher.

La taille d’une région est limitée à 32 767 par 32 767 unités logiques ou 64 Ko de mémoire, selon ce qui est plus petit.

Lorsque le mode de remplissage de polygones est ALTERNATE, le système remplit la zone entre les côtés impairs et pairs des polygones sur chaque ligne d’analyse. Autrement dit, le système remplit la zone entre le premier et le deuxième côté, entre le troisième et le quatrième côté, et ainsi de suite.

Lorsque le mode de remplissage de polygones est WINDING, le système utilise la direction dans laquelle une figure a été dessinée pour déterminer s’il faut remplir une zone. Chaque segment de ligne d’un polygone est dessiné dans le sens des aiguilles d’une montre ou dans un sens inverse. Chaque fois qu’une ligne imaginaire dessinée d’une zone fermée à l’extérieur d’une figure passe par un segment de ligne au niveau des aiguilles d’une montre, un nombre est incrémenté. Lorsque la ligne passe par un segment de ligne dans le sens inverse, le nombre est décrémenté. La zone est remplie si le nombre est différent de zéro lorsque la ligne atteint l’extérieur de la figure.

Lorsqu’une application a fini d’utiliser une région créée avec la CreatePolyPolygonRgn fonction, elle doit sélectionner la région hors du contexte de l’appareil et utiliser la fonction membre CGDIObject ::D eleteObject pour la supprimer.

CRgn ::CreateRectRgn

Crée une région rectangulaire stockée dans l’objet CRgn .

BOOL CreateRectRgn(
    int x1,
    int y1,
    int x2,
    int y2);

Paramètres

x1
Spécifie la coordonnée x logique du coin supérieur gauche de la région.

y1
Spécifie la coordonnée y logique du coin supérieur gauche de la région.

x2
Spécifie la coordonnée x logique du coin inférieur droit de la région.

y2
Spécifie la coordonnée y logique du coin inférieur droit de la région.

Valeur de retour

Différent de zéro si l’opération a réussi ; sinon 0.

Notes

La taille d’une région est limitée à 32 767 par 32 767 unités logiques ou 64 Ko de mémoire, selon ce qui est plus petit.

Une fois qu’elle a fini d’utiliser une région créée par CreateRectRgn, une application doit utiliser la fonction membre CGDIObject ::D eleteObject pour supprimer la région.

Exemple

CRgn   rgn;

BOOL bSucceeded = rgn.CreateRectRgn(50, 20, 150, 120);
ASSERT(bSucceeded == TRUE);

Pour obtenir un exemple supplémentaire, consultez CRgn ::CombineRgn.

CRgn ::CreateRectRgnIndirect

Crée une région rectangulaire stockée dans l’objet CRgn .

BOOL CreateRectRgnIndirect(LPCRECT lpRect);

Paramètres

lpRect
Pointe vers une structure ou CRect un RECT objet qui contient les coordonnées logiques des coins supérieur gauche et inférieur droit de la région. La RECT structure a la forme suivante :

typedef struct tagRECT {
    int left;
    int top;
    int right;
    int bottom;
} RECT;

Valeur de retour

Différent de zéro si l’opération a réussi ; sinon 0.

Notes

La taille d’une région est limitée à 32 767 par 32 767 unités logiques ou 64 Ko de mémoire, selon ce qui est plus petit.

Une fois qu’elle a fini d’utiliser une région créée par CreateRectRgnIndirect, une application doit utiliser la fonction membre CGDIObject ::D eleteObject pour supprimer la région.

Exemple

CRgn   rgnA, rgnB, rgnC;

CRect rectA(50, 50, 150, 150);
CRect rectB(100, 50, 200, 150);

VERIFY(rgnA.CreateRectRgnIndirect(&rectA));
VERIFY(rgnB.CreateEllipticRgnIndirect(&rectB));
VERIFY(rgnC.CreateRectRgn( 0, 0, 50, 50 ));

int nCombineResult = rgnC.CombineRgn( &rgnA, &rgnB, RGN_AND );
ASSERT( nCombineResult != ERROR && nCombineResult != NULLREGION );

CBrush brA, brB, brC;
VERIFY(brA.CreateSolidBrush( RGB(255, 0, 0) ));  
VERIFY(pDC->FrameRgn( &rgnA, &brA, 2, 2 ));      // rgnA Red

VERIFY(brB.CreateSolidBrush( RGB(0, 255, 0) ));  
VERIFY(pDC->FrameRgn( &rgnB, &brB, 2, 2 ));      // rgnB Green
VERIFY(brC.CreateSolidBrush( RGB(0, 0, 255) ));  // rgnC Blue
VERIFY(pDC->FrameRgn( &rgnC, &brC, 2, 2 ));

CRgn ::CreateRoundRectRgn

Crée une zone rectangulaire avec des angles arrondis stockés dans l’objet CRgn .

BOOL CreateRoundRectRgn(
    int x1,
    int y1,
    int x2,
    int y2,
    int x3,
    int y3);

Paramètres

x1
Spécifie la coordonnée x logique du coin supérieur gauche de la région.

y1
Spécifie la coordonnée y logique du coin supérieur gauche de la région.

x2
Spécifie la coordonnée x logique du coin inférieur droit de la région.

y2
Spécifie la coordonnée y logique du coin inférieur droit de la région.

x3
Spécifie la largeur de l’ellipse utilisée pour créer les angles arrondis.

y3
Spécifie la hauteur de l’ellipse utilisée pour créer les angles arrondis.

Valeur de retour

Différent de zéro si l’opération a réussi ; sinon 0.

Notes

La taille d’une région est limitée à 32 767 par 32 767 unités logiques ou 64 Ko de mémoire, selon ce qui est plus petit.

Lorsqu’une application a fini d’utiliser une région créée avec la CreateRoundRectRgn fonction, elle doit sélectionner la région hors du contexte de l’appareil et utiliser la fonction membre CGDIObject ::D eleteObject pour la supprimer.

Exemple

CRgn   rgnA, rgnB, rgnC;

VERIFY(rgnA.CreateRoundRectRgn( 50, 50, 150, 150, 30, 30 ));
VERIFY(rgnB.CreateRoundRectRgn( 200, 75, 250, 125, 50, 50 ));
VERIFY(rgnC.CreateRectRgn( 0, 0, 50, 50 ));

int nCombineResult = rgnC.CombineRgn( &rgnA, &rgnB, RGN_OR );
ASSERT( nCombineResult != ERROR && nCombineResult != NULLREGION );

CBrush brA, brB, brC;
VERIFY(brA.CreateSolidBrush( RGB(255, 0, 0) ));  
VERIFY(pDC->FillRgn( &rgnA, &brA));      // rgnA Red Filled

VERIFY(brB.CreateSolidBrush( RGB(0, 255, 0) ));  
VERIFY(pDC->FillRgn( &rgnB, &brB));      // rgnB Green Filled
VERIFY(brC.CreateSolidBrush( RGB(0, 0, 255) ));  // rgnC Blue
VERIFY(pDC->FrameRgn( &rgnC, &brC, 2, 2 ));

CRgn ::CRgn

Construit un objet CRgn.

CRgn();

Notes

Le m_hObject membre de données ne contient pas de région GDI Windows valide tant que l’objet n’est pas initialisé avec une ou plusieurs des autres CRgn fonctions membres.

Exemple

Consultez l’exemple de CRgn ::CreateRoundRectRgn.

CRgn ::EqualRgn

Détermine si la région donnée est équivalente à la région stockée dans l’objet CRgn .

BOOL EqualRgn(CRgn* pRgn) const;

Paramètres

pRgn
Identifie une région.

Valeur de retour

Différent de zéro si les deux régions sont équivalentes ; sinon 0.

Exemple

CRgn   rgnA, rgnB;

VERIFY(rgnA.CreateEllipticRgn(200, 100, 350, 250));
VERIFY(rgnB.CreateRectRgn(0, 0, 50, 50));
VERIFY(rgnB.CopyRgn(&rgnA));
int nOffsetResult = rgnB.OffsetRgn(-75, 75);
ASSERT(nOffsetResult != ERROR && nOffsetResult != NULLREGION);
ASSERT(FALSE == rgnB.EqualRgn(&rgnA));

CRgn ::FromHandle

Retourne un pointeur vers un CRgn objet lorsqu’un handle est donné à une région Windows.

static CRgn* PASCAL FromHandle(HRGN hRgn);

Paramètres

hRgn
Spécifie un handle dans une région Windows.

Valeur de retour

Pointeur vers un objet CRgn. Si la fonction n’a pas réussi, la valeur de retour est NULL.

Notes

Si un CRgn objet n’est pas déjà attaché au handle, un objet temporaire CRgn est créé et attaché. Cet objet temporaire CRgn est valide uniquement jusqu’à la prochaine fois que l’application a un temps d’inactivité dans sa boucle d’événements, auquel cas tous les objets graphiques temporaires sont supprimés. Une autre façon de dire ceci est que l’objet temporaire n’est valide que pendant le traitement d’un message de fenêtre.

CRgn ::GetRegionData

Remplit la mémoire tampon spécifiée avec des données décrivant la région.

int GetRegionData(
    LPRGNDATA lpRgnData,
    int nCount) const;

Paramètres

lpRgnData
Pointe vers une structure de données RGNDATA qui reçoit les informations. Si ce paramètre est NULL, la valeur de retour contient le nombre d’octets nécessaires pour les données de région.

nCount
Spécifie la taille, en octets, de la mémoire tampon lpRgnData .

Valeur de retour

Si la fonction réussit et que nCount spécifie un nombre adéquat d’octets, la valeur de retour est toujours nCount. Si la fonction échoue ou si nCount spécifie un nombre inférieur à suffisant d’octets, la valeur de retour est 0 (erreur).

Notes

Ces données incluent les dimensions des rectangles qui composent la région. Cette fonction est utilisée conjointement avec la CRgn::CreateFromData fonction.

CRgn ::GetRgnBox

Récupère les coordonnées du rectangle englobant de l’objet CRgn .

int GetRgnBox(LPRECT lpRect) const;

Paramètres

lpRect
Pointe vers une structure ou CRect un RECT objet pour recevoir les coordonnées du rectangle englobant. La RECT structure a la forme suivante :

typedef struct tagRECT {

int left;

int top;

int right;

int bottom;

} RECT;

Valeur de retour

Spécifie le type de la région. Il peut s’agir de l’une des valeurs suivantes :

  • La région COMPLEXREGION a des bordures qui se chevauchent.

  • La région NULLREGION est vide.

  • L’objet ERROR CRgn ne spécifie pas de région valide.

  • La région SIMPLEREGION n’a pas de bordures qui se chevauchent.

Exemple

Consultez l’exemple de CRgn ::CreatePolygonRgn.

CRgn ::OffsetRgn

Déplace la région stockée dans l’objet CRgn par les décalages spécifiés.

int OffsetRgn(
    int x,
    int y);

int OffsetRgn(POINT point);

Paramètres

x
Spécifie le nombre d’unités à déplacer vers la gauche ou la droite.

y
Spécifie le nombre d’unités à déplacer vers le haut ou vers le bas.

point
La coordonnée x du point spécifie le nombre d’unités à déplacer vers la gauche ou la droite. La coordonnée y du point spécifie le nombre d’unités à déplacer vers le haut ou vers le bas. Le paramètre de point peut être une POINT structure ou un CPoint objet.

Valeur de retour

Type de la nouvelle région. Il peut s’agir de l’une des valeurs suivantes :

  • La région COMPLEXREGION a des bordures qui se chevauchent.

  • Le handle de région ERROR n’est pas valide.

  • La région NULLREGION est vide.

  • La région SIMPLEREGION n’a pas de bordures qui se chevauchent.

Notes

La fonction déplace la région x unités le long de l’axe x et des unités y le long de l’axe y.

Les valeurs de coordonnées d’une région doivent être inférieures ou égales à 32 767 et supérieures ou égales à -32 768. Les paramètres x et y doivent être soigneusement choisis pour empêcher les coordonnées de région non valides.

Exemple

Consultez l’exemple de CRgn ::CreateEllipticRgn.

CRgn ::operator HRGN

Utilisez cet opérateur pour obtenir le handle GDI Windows attaché de l’objet CRgn .

operator HRGN() const;

Valeur de retour

Si elle réussit, un handle vers l’objet GDI Windows représenté par l’objet CRgn ; sinon NULL.

Notes

Cet opérateur est un opérateur de cast, qui prend en charge l’utilisation directe d’un objet HRGN.

Pour plus d’informations sur l’utilisation d’objets graphiques, consultez l’article Objets graphiques dans le Kit de développement logiciel (SDK) Windows.

CRgn ::P tInRegion

Vérifie si le point donné par x et y se trouve dans la région stockée dans l’objet CRgn .

BOOL PtInRegion(
    int x,
    int y) const;

BOOL PtInRegion(POINT point) const;

Paramètres

x
Spécifie la coordonnée x logique du point à tester.

y
Spécifie la coordonnée y logique du point à tester.

point
Les coordonnées x et y du point spécifient les coordonnées x et y du point pour tester la valeur de. Le paramètre de point peut être une POINT structure ou un CPoint objet.

Valeur de retour

Différent de zéro si le point se trouve dans la région ; sinon 0.

CRgn ::RectInRegion

Détermine si une partie du rectangle spécifié par lpRect se trouve dans les limites de la région stockée dans l’objet CRgn .

BOOL RectInRegion(LPCRECT lpRect) const;

Paramètres

lpRect
Pointe vers une structure ou CRect un RECT objet. La RECT structure a la forme suivante :

typedef struct tagRECT {
    int left;
    int top;
    int right;
    int bottom;
} RECT;

Valeur de retour

Différent de zéro si une partie du rectangle spécifié se trouve dans les limites de la région ; sinon 0.

CRgn ::SetRectRgn

Crée une région rectangulaire.

void SetRectRgn(
    int x1,
    int y1,
    int x2,
    int y2);

void SetRectRgn(LPCRECT lpRect);

Paramètres

x1
Spécifie la coordonnée x du coin supérieur gauche de la région rectangulaire.

y1
Spécifie la coordonnée y du coin supérieur gauche de la région rectangulaire.

x2
Spécifie la coordonnée x du coin inférieur droit de la région rectangulaire.

y2
Spécifie la coordonnée y du coin inférieur droit de la région rectangulaire.

lpRect
Spécifie la région rectangulaire. Peut être un pointeur vers une RECT structure ou un CRect objet.

Notes

Contrairement à CreateRectRgn, toutefois, il n’alloue pas de mémoire supplémentaire à partir du tas d’application Windows local. Au lieu de cela, il utilise l’espace alloué pour la région stockée dans l’objet CRgn . Cela signifie que l’objet CRgn doit déjà avoir été initialisé avec une région Windows valide avant d’appeler SetRectRgn. Les points donnés par x1, y1, x2 et y2 spécifient la taille minimale de l’espace alloué.

Utilisez cette fonction au lieu de la CreateRectRgn fonction membre pour éviter les appels au gestionnaire de mémoire local.

Voir aussi

CWnd, classe
Graphique hiérarchique