`CRect` Sınıf

Makale
07/05/2024

Windows RECT yapısına benzer.

Sözdizimi

class CRect : public tagRECT

Üyeler

Ortak Oluşturucular

Veri Akışı Adı	Açıklama
`CRect::CRect`	Bir `CRect` nesne oluşturur.

Genel Yöntemler

Veri Akışı Adı	Açıklama
`CRect::BottomRight`	öğesinin sağ alt noktasını `CRect`döndürür.
`CRect::CenterPoint`	öğesinin merkez noktasını `CRect`döndürür.
`CRect::CopyRect`	Kaynak dikdörtgenin boyutlarını öğesine `CRect`kopyalar.
`CRect::DeflateRect`	genişliğini ve yüksekliğini `CRect`azaltır.
`CRect::EqualRect`	Verilen dikdörtgene eşit olup olmadığını `CRect` belirler.
`CRect::Height`	yüksekliğini `CRect`hesaplar.
`CRect::InflateRect`	genişliğini ve yüksekliğini `CRect`artırır.
`CRect::IntersectRect`	İki dikdörtgenin kesişimine eşit ayarlar `CRect` .
`CRect::IsRectEmpty`	Boş olup olmadığını `CRect` belirler. `CRect` genişlik ve/veya yükseklik 0 ise boş olur.
`CRect::IsRectNull`	, , `bottomleft`ve `right` üye değişkenlerinin tümünün `top`0'a eşit olup olmadığını belirler.
`CRect::MoveToX`	Belirtilen x koordinatını taşır `CRect` .
`CRect::MoveToXY`	Belirtilen x ve y koordinatlarına taşınır `CRect` .
`CRect::MoveToY`	Belirtilen y koordinatını taşır `CRect` .
`CRect::NormalizeRect`	yüksekliğini ve genişliğini `CRect`standartlaştırır.
`CRect::OffsetRect`	Belirtilen uzaklıklara göre hareket `CRect` eder.
`CRect::PtInRect`	Belirtilen noktanın içinde `CRect`olup olmadığını belirler.
`CRect::SetRect`	boyutlarını `CRect`ayarlar.
`CRect::SetRectEmpty`	Boş bir dikdörtgene ayarlar `CRect` (tüm koordinatlar 0'a eşittir).
`CRect::Size`	boyutunu `CRect`hesaplar.
`CRect::SubtractRect`	Bir dikdörtgeni diğerinden çıkarır.
`CRect::TopLeft`	öğesinin sol üst noktasını `CRect`döndürür.
`CRect::UnionRect`	İki dikdörtgenin birleşimine eşit ayarlar `CRect` .
`CRect::Width`	genişliğini `CRect`hesaplar.

Ortak İşleçler

Veri Akışı Adı	Açıklama
`CRect::operator -`	Verilen uzaklıkları içinden `CRect` çıkarır veya söndürer `CRect` ve sonuçta `CRect`elde edilen değerini döndürür.
`CRect::operator LPCRECT`	bir'i `CRect` öğesine `LPCRECT`dönüştürür.
`CRect::operator LPRECT`	bir'i `CRect` öğesine `LPRECT`dönüştürür.
`CRect::operator !=`	Dikdörtgene eşit olup olmadığını `CRect` belirler.
`CRect::operator &`	ile dikdörtgenin kesişimini `CRect` oluşturur ve sonuçta elde edilen `CRect`değerini döndürür.
`CRect::operator &=`	ve dikdörtgenin kesişimine `CRect` eşit ayarlar`CRect`.
`CRect::operator \|`	ve dikdörtgeninin birleşimini `CRect` oluşturur ve sonuçta elde edilen `CRect`değerini döndürür.
`CRect::operator \|=`	ve bir dikdörtgenin birleşimine `CRect` eşit ayarlar`CRect`.
`CRect::operator +`	Verilen uzaklıkları öğesine `CRect` ekler veya şişirir `CRect` ve sonuçta `CRect`elde edilen değerini döndürür.
`CRect::operator +=`	Belirtilen uzaklıkları öğesine `CRect` ekler veya şişirir `CRect`.
`CRect::operator =`	Dikdörtgenin boyutlarını öğesine `CRect`kopyalar.
`CRect::operator -=`	Belirtilen uzaklıkları içinden `CRect` çıkarır veya söndürebilir `CRect`.
`CRect::operator ==`	Dikdörtgene eşit olup olmadığını `CRect` belirler.

Açıklamalar

CRectayrıca nesneleri ve Windows RECT yapılarını işlemek CRect için üye işlevleri içerir.

Bir CRect nesne, bir yapı olan LPCRECTher yerde RECT işlev parametresi olarak geçirilebilir veya LPRECT geçirilebilir.

Not

Bu sınıf yapısından tagRECT türetilir. (Ad tagRECT , yapı için RECT daha az yaygın kullanılan bir addır.) Bu, yapının veri üyelerinin (left, top, rightve bottom) RECT erişilebilir veri üyeleri CRectolduğu anlamına gelir.

A CRect , bir dikdörtgenin sol üst ve sağ alt noktalarını tanımlayan üye değişkenleri içerir.

belirtirken CRect, bunu normalleştirilecek şekilde, diğer bir deyişle, sol koordinatın değeri sağdan küçük ve üst alttan küçük olacak şekilde oluşturmak için dikkatli olmanız gerekir. Örneğin, (20,20) öğesinin sol üst (10,10) ve sağ alt kısmı normalleştirilmiş bir dikdörtgen tanımlar, ancak sol üst (20,20) ve sağ alt (10,10) normalleştirilmemiş bir dikdörtgen tanımlar. Dikdörtgen normalleştirilmemişse, birçok CRect üye işlevi yanlış sonuçlar döndürebilir. (Bu işlevlerin listesi için bkz CRect::NormalizeRect . Normalleştirilmiş dikdörtgenler gerektiren bir işlevi çağırmadan önce, işlevi çağırarak NormalizeRect normalleştirilmemiş dikdörtgenleri normalleştirebilirsiniz.

ve CDC::LPtoDP üye işlevleriyle CDC::DPtoLP bir'i CRect düzenlerken dikkatli olun. Görüntü bağlamının eşleme modu, içinde olduğu gibi y-extent negatif olacak şekildeyseMM_LOENGLISHCDC::DPtoLP, öğesini dönüştürerek CRect üst öğesini alttan büyük olur. ve gibi Height Size işlevler dönüştürülen CRectöğesinin yüksekliği için negatif değerler döndürür ve dikdörtgen normalleştirilmeyecektir.

Aşırı yüklenmiş CRect işleçler kullanılırken, ilk işlenen bir CRectolmalıdır; ikincisi bir RECT yapı veya nesne CRect olabilir.

Devralma Hiyerarşisi

tagRECT

CRect

Gereksinimler

Üstbilgi: atltypes.h

`CRect::BottomRight`

Koordinatlar içinde bulunan CRectbir CPoint nesneye başvuru olarak döndürülür.

CPoint& BottomRight() throw();
const CPoint& BottomRight() const throw();

Dönüş Değeri

Dikdörtgenin sağ alt köşesinin koordinatları.

Açıklamalar

Dikdörtgenin sağ alt köşesini almak veya ayarlamak için bu işlevi kullanabilirsiniz. Atama işlecinin sol tarafındaki bu işlevi kullanarak köşeyi ayarlayın.

Örnek

// use BottomRight() to retrieve the bottom
// right POINT
CRect rect(210, 150, 350, 900);
CPoint ptDown;

ptDown = rect.BottomRight();

// ptDown is now set to (350, 900)
ASSERT(ptDown == CPoint(350, 900));

// or, use BottomRight() to set the bottom
// right POINT
CRect rect2(10, 10, 350, 350);
CPoint ptLow(180, 180);

CRect rect2(10, 10, 350, 350);
CPoint ptLow(180, 180);
rect2.BottomRight() = ptLow;

// rect2 is now (10, 10, 180, 180)
ASSERT(rect2 == CRect(10, 10, 180, 180));

`CRect::CenterPoint`

Sol ve sağ değerleri ekleyerek ve ikiye bölerek, üst ve alt değerleri ekleyip ikiye bölerek öğesinin merkez noktasını CRect hesaplar.

CPoint CenterPoint() const throw();

Dönüş Değeri

CPoint öğesinin merkez noktası CRectolan bir nesne.

Örnek

// Code from this OnPaint() implementation can be pasted into your own application
// to draw lines that would look like a letter "Y" within your dialog.
void CMyDlg::OnPaint()
{
    CPaintDC dc(this);

    // device context for painting

    // get the size and position of the client area of
    // your window

    CRect rect;
    GetClientRect(&rect);

    // Move the current pen to the top left of the window. We call the
    // TopLeft() member of CRect here and it returns a CPoint object we
    // pass to the override of CDC::MoveTo() that accepts a CPoint.

    dc.MoveTo(rect.TopLeft());

    // Draw a line from the top left to the center of the window.
    // CenterPoint() gives us the middle point of the window as a
    // CPoint, and since CDC::LineTo() has an override that accepts a
    // CPoint, we can just pass it along.

    dc.LineTo(rect.CenterPoint());

    // Now, draw a line to the top right of the window. There's no
    // CRect member which returns a CPoint for the top right of the
    // window, so we'll reference the CPoint members directly and call
    // the CDC::LineTo() override which takes two integers.

    dc.LineTo(rect.right, rect.top);

    // The top part of the "Y" is drawn. Now, we'll draw the stem. We
    // start from the center point.

    dc.MoveTo(rect.CenterPoint());

    // and then draw to the middle of the bottom edge of the window.
    // We'll get the x-coordinate from the x member of the CPOINT
    // returned by CenterPoint(), and the y value comes directly from
    // the rect.

    dc.LineTo(rect.CenterPoint().x, rect.bottom);
}

`CRect::CopyRect`

Dikdörtgeni lpSrcRect içine CRectkopyalar.

void CopyRect(LPCRECT lpSrcRect) throw();

Parametreler

lpSrcRect
RECT Kopyalanacak yapıyı veya CRect nesneyi gösterir.

Örnek

CRect rectSource(35, 10, 125, 10);
CRect rectDest;

rectDest.CopyRect(&rectSource);

// rectDest is now set to (35, 10, 125, 10)

RECT rectSource2;
rectSource2.left = 0;
rectSource2.top = 0;
rectSource2.bottom = 480;
rectSource2.right = 640;

rectDest.CopyRect(&rectSource2);

// works against RECT structures, too!
// rectDest is now set to (0, 0, 640, 480)

`CRect::CRect`

Bir CRect nesne oluşturur.

CRect() throw();
CRect(int l, int t, int r, int b) throw();
CRect(const RECT& srcRect) throw();
CRect(LPCRECT lpSrcRect) throw();
CRect(POINT point, SIZE size) throw();
CRect(POINT topLeft, POINT bottomRight) throw();

Parametreler

l
öğesinin sol konumunu CRectbelirtir.

t
öğesinin üst kısmını CRectbelirtir.

r
öğesinin doğru konumunu CRectbelirtir.

b
öğesinin alt kısmını CRectbelirtir.

srcRect
RECT için koordinatları olan yapıyı ifade ederCRect.

lpSrcRect
RECT için koordinatları olan yapıya işaret ederCRect.

point
Dikdörtgenin oluşturulacağı çıkış noktasını belirtir. Sol üst köşeye karşılık gelir.

size
Oluşturulacak dikdörtgenin sol üst köşesinden sağ alt köşesine yer değiştirme işlemini belirtir.

topLeft
öğesinin sol üst konumunu CRectbelirtir.

bottomRight
öğesinin sağ alt konumunu CRectbelirtir.

Açıklamalar

Bağımsız değişken verilmezse, left, top, rightve bottom üyeleri 0 olarak ayarlanır.

CRect(const RECT&) ve CRect(LPCRECT) oluşturucuları bir CopyRectgerçekleştirir. Diğer oluşturucular nesnenin üye değişkenlerini doğrudan başlatır.

Örnek

// default constructor is equivalent to CRect(0, 0, 0, 0)
CRect emptyRect;

// four-integers are left, top, right, and bottom
CRect rect(0, 0, 100, 50);
ASSERT(rect.Width() == 100);
ASSERT(rect.Height() == 50);

// Initialize from RECT structure
RECT sdkRect;
sdkRect.left = 0;
sdkRect.top = 0;
sdkRect.right = 100;
sdkRect.bottom = 50;

CRect rect2(sdkRect);
// by reference
CRect rect3(&sdkRect);

// by address
ASSERT(rect2 == rect);
ASSERT(rect3 == rect);

// from a point and a size
CPoint pt(0, 0);
CSize sz(100, 50);
CRect rect4(pt, sz);
ASSERT(rect4 == rect2);

// from two points
CPoint ptBottomRight(100, 50);
CRect rect5(pt, ptBottomRight);
ASSERT(rect5 == rect4);

`CRect::DeflateRect`

DeflateRect yanlarını merkezine doğru hareket ettirerek söndürün CRect .

void DeflateRect(int x, int y) throw();
void DeflateRect(SIZE size) throw();
void DeflateRect(LPCRECT lpRect) throw();
void DeflateRect(int l, int t, int r, int b) throw();

Parametreler

x
öğesinin sol ve sağ kenarlarının CRectsöndürileceği birim sayısını belirtir.

y
öğesinin üst ve alt CRectkısmının söndürileceği birim sayısını belirtir.

size
A SIZE veya CSize boşaltacak CRectbirim sayısını belirtir. cx değeri, sol ve sağ kenarların söndürileceği birim sayısını, değer ise cy üst ve alt kısımdaki birimlerin sayısını belirtir.

lpRect
Bir RECT yapıya işaret eder veya CRect her kenarın söndürileceği birim sayısını belirtir.

l
sol tarafının CRectsöndürileceği birim sayısını belirtir.

t
öğesinin üst CRectkısmının söndürileceği birim sayısını belirtir.

r
sağ tarafının CRectsöndürileceği birim sayısını belirtir.

b
öğesinin alt CRectkısmının söndürileceği birim sayısını belirtir.

Açıklamalar

Bunu yapmak için, DeflateRect birimleri sola ve üste ekler ve sağdan ve alttan çıkarır. parametreleri DeflateRect imzalı değerlerdir; pozitif değerler şişer CRect ve negatif değerler onu şişirir.

İlk iki aşırı yükleme, toplam genişliğinin iki kez (veya ) ve toplam yüksekliğinin iki kez y x (cyveya cx) azalması için her iki karşı taraf CRect çiftini de söndürmektedir. Diğer iki aşırı yükleme, diğer iki aşırı yüklemeden bağımsız olarak her iki CRect tarafını da söndürmektedir.

Örnek

CRect rect(10, 10, 50, 50);
rect.DeflateRect(1, 2);
ASSERT(rect.left == 11 && rect.right == 49);
ASSERT(rect.top == 12 && rect.bottom == 48);

CRect rect2(10, 10, 50, 50);
CRect rectDeflate(1, 2, 3, 4);
rect2.DeflateRect(&rectDeflate);
ASSERT(rect2.left == 11 && rect2.right == 47);
ASSERT(rect2.top == 12 && rect2.bottom == 46);

`CRect::EqualRect`

Verilen dikdörtgene eşit olup olmadığını CRect belirler.

BOOL EqualRect(LPCRECT lpRect) const throw();

Parametreler

lpRect
Dikdörtgenin RECT sol üst ve sağ alt köşe koordinatlarını içeren bir yapıya veya CRect nesneye işaret eder.

Dönüş Değeri

İki dikdörtgen aynı üst, sol, alt ve sağ değerlere sahipse sıfır olmayan; aksi takdirde 0.

Not

Dikdörtgenlerin her ikisi de normalleştirilmelidir, aksi durumda bu işlev başarısız olabilir. Bu işlevi çağırmadan önce dikdörtgenleri normalleştirmek için çağırabilirsiniz NormalizeRect .

Örnek

CRect rect1(35, 150, 10, 25);
CRect rect2(35, 150, 10, 25);
CRect rect3(98, 999, 6, 3);
ASSERT(rect1.EqualRect(rect2));
ASSERT(!rect1.EqualRect(rect3));
// works just fine against RECTs, as well

RECT test;
test.left = 35;
test.top = 150;
test.right = 10;
test.bottom = 25;

ASSERT(rect1.EqualRect(&test));

`CRect::Height`

En üstteki değeri alt değerden çıkararak yüksekliğini CRect hesaplar.

int Height() const throw();

Dönüş Değeri

yüksekliği CRect.

Açıklamalar

Sonuçta elde edilen değer negatif olabilir.

Not

Dikdörtgen normalleştirilmelidir, aksi durumda bu işlev başarısız olabilir. Bu işlevi çağırmadan önce dikdörtgeni normalleştirmek için çağırabilirsiniz NormalizeRect .

Örnek

CRect rect(20, 30, 80, 70);
int nHt = rect.Height();

// nHt is now 40
ASSERT(nHt == 40);

`CRect::InflateRect`

InflateRect yanlarını merkezinden uzaklaştırarak şişirir CRect .

void InflateRect(int x, int y) throw();
void InflateRect(SIZE size) throw();
void InflateRect(LPCRECT lpRect) throw();
void InflateRect(int l, int t, int r,  int b) throw();

Parametreler

x
öğesinin sol ve sağ kenarlarını CRectşişirmek için birim sayısını belirtir.

y
öğesinin üst ve alt CRectkısmını şişirmek için birim sayısını belirtir.

size
şişirmek SIZE CRectiçin birim sayısını belirten bir veya CSize . cx değeri, sol ve sağ kenarları şişirmek için birim sayısını, cy üst ve altta şişirmek için birim sayısını belirtir.

lpRect
Bir RECT yapıya işaret eder veya CRect her bir tarafı şişirmek için birim sayısını belirtir.

l
öğesinin sol tarafını CRectşişirmek için birim sayısını belirtir.

t
öğesinin üst CRectkısmını şişirmek için birim sayısını belirtir.

r
öğesinin sağ tarafını CRectşişirmek için birim sayısını belirtir.

b
öğesinin alt CRectkısmını şişirmek için birim sayısını belirtir.

Açıklamalar

Bunu yapmak için, InflateRect birimleri soldan ve üstten çıkarır ve sağ ve alta birim ekler. parametreleri InflateRect imzalı değerlerdir; pozitif değerler şişirilir CRect ve negatif değerler onu şişirir.

İlk iki aşırı yükleme, toplam genişliğinin iki kat (veya ) artırılması ve toplam yüksekliğinin CRect iki kat x y (veya cxcy) artırılması için her iki karşıt tarafının çiftini de şişirir. Diğer iki aşırı yükleme, diğerlerinden bağımsız olarak her iki CRect tarafını şişirir.

Örnek

CRect rect(0, 0, 300, 300);
rect.InflateRect(50, 200);

// rect is now (-50, -200, 350, 500)
ASSERT(rect == CRect(-50, -200, 350, 500));

`CRect::IntersectRect`

Mevcut iki dikdörtgenin kesişimine eşit olur CRect .

BOOL IntersectRect(LPCRECT lpRect1, LPCRECT lpRect2) throw();

Parametreler

lpRect1
Kaynak dikdörtgen içeren bir RECT yapıyı veya CRect nesneyi gösterir.

lpRect2
Kaynak dikdörtgen içeren bir RECT yapıyı veya CRect nesneyi gösterir.

Dönüş Değeri

Kesişim boş değilse sıfır olmayan; Kesişim boşsa 0.

Açıklamalar

Kesişim, mevcut dikdörtgenlerin her ikisinde de bulunan en büyük dikdörtgendir.

Not

Örnek

CRect rectOne(125,  0, 150, 200);
CRect rectTwo(0, 75, 350, 95);
CRect rectInter;

rectInter.IntersectRect(rectOne, rectTwo);
ASSERT(rectInter == CRect(125, 75, 150, 95));
// operator &= can do the same task:

CRect rectInter2 = rectOne;
rectInter2 &= rectTwo;
ASSERT(rectInter2 == CRect(125, 75, 150, 95));

`CRect::IsRectEmpty`

Boş olup olmadığını CRect belirler.

BOOL IsRectEmpty() const throw();

Dönüş Değeri

Boşsa CRect sıfır olmayan; boş değilse CRect 0.

Açıklamalar

Genişlik ve/veya yükseklik 0 veya negatifse dikdörtgen boş olur. dikdörtgenin IsRectNulltüm koordinatlarının sıfır olup olmadığını belirleyen ile farklıdır.

Not

Dikdörtgen normalleştirilmelidir, aksi durumda bu işlev başarısız olabilir. Bu işlevi çağırmadan önce dikdörtgeni normalleştirmek için çağırabilirsiniz NormalizeRect .

Örnek

CRect rectNone(0, 0, 0, 0);
CRect rectSome(35, 50, 135, 150);
ASSERT(rectNone.IsRectEmpty());
ASSERT(!rectSome.IsRectEmpty());
CRect rectEmpty(35, 35, 35, 35);
ASSERT(rectEmpty.IsRectEmpty());

`CRect::IsRectNull`

öğesinin üst, sol, alt ve sağ değerlerinin CRect 0'a eşit olup olmadığını belirler.

BOOL IsRectNull() const throw();

Dönüş Değeri

Sıfır olmayan değer ise CRectüst, sol, alt ve sağ değerlerinin tümü 0'a eşittir; aksi takdirde 0'dır.

Açıklamalar

dikdörtgenin boş olup olmadığını belirleyen ile IsRectEmptyfarklıdır.

Örnek

CRect rectNone(0, 0, 0, 0);
CRect rectSome(35, 50, 135, 150);
ASSERT(rectNone.IsRectNull());
ASSERT(!rectSome.IsRectNull());
// note that null means _all_ zeros

CRect rectNotNull(0, 0, 35, 50);
ASSERT(!rectNotNull.IsRectNull());

`CRect::MoveToX`

Dikdörtgeni tarafından xbelirtilen mutlak x koordinatlarına taşımak için bu işlevi çağırın.

void MoveToX(int x) throw();

Parametreler

x
Dikdörtgenin sol üst köşesi için mutlak x koordinatı.

Örnek

CRect rect(0, 0, 100, 100);
rect.MoveToX(10);

// rect is now (10, 0, 110, 100);
ASSERT(rect == CRect(10, 0, 110, 100));

`CRect::MoveToXY`

Dikdörtgeni belirtilen mutlak x ve y koordinatlarına taşımak için bu işlevi çağırın.

void MoveToXY(int x, int y) throw();
void MoveToXY(POINT point) throw();

Parametreler

x
Dikdörtgenin sol üst köşesi için mutlak x koordinatı.

y
Dikdörtgenin sol üst köşesi için mutlak y koordinatı.

point
POINT Dikdörtgenin mutlak sol üst köşesini belirten bir yapı.

Örnek

CRect rect(0, 0, 100, 100);
rect.MoveToXY(10, 10);
// rect is now (10, 10, 110, 110);
ASSERT(rect == CRect(10, 10, 110, 110));

`CRect::MoveToY`

Dikdörtgeni tarafından ybelirtilen mutlak y koordinatını taşımak için bu işlevi çağırın.

void MoveToY(int y) throw();

Parametreler

y
Dikdörtgenin sol üst köşesi için mutlak y koordinatı.

Örnek

CRect rect(0, 0, 100, 100);
rect.MoveToY(10);
// rect is now (0, 10, 100, 110);
ASSERT(rect == CRect(0, 10, 100, 110));

`CRect::NormalizeRect`

Hem yükseklik hem de genişlik pozitif olacak şekilde normalleştirir CRect .

void NormalizeRect() throw();

Açıklamalar

Dikdörtgen, Windows'un genellikle koordinatlar için kullandığı dördüncü çeyrek konumlandırma için normalleştirilir. NormalizeRect üst ve alt değerleri karşılaştırır ve üst değer alttan büyükse bunları değiştirir. Benzer şekilde, sol ve sağdan büyükse, sol ve sağ değerleri değiştirir. Bu işlev, farklı eşleme modları ve ters dikdörtgenlerle çalışırken kullanışlıdır.

Not

Aşağıdaki CRect üye işlevleri düzgün çalışmak için normalleştirilmiş dikdörtgenler gerektirir: Height, Width, Size, IsRectEmpty, PtInRect, , EqualRect, UnionRect, IntersectRect, SubtractRect, , operator ==, operator |=operator &operator !=operator |ve .operator &=

Örnek

CRect rect1(110, 100, 250, 310);
CRect rect2(250, 310, 110, 100);
rect1.NormalizeRect();
rect2.NormalizeRect();
ASSERT(rect1 == rect2);

`CRect::OffsetRect`

Belirtilen uzaklıklara göre hareket CRect eder.

void OffsetRect(int x, int y) throw();
void OffsetRect(POINT point) throw();
void OffsetRect(SIZE size) throw();

Parametreler

x
Sola veya sağa taşınacak miktarı belirtir. Sola gitmek için negatif olmalıdır.

y
Yukarı veya aşağı taşınacak miktarı belirtir. Yukarı taşımak için negatif olmalıdır.

point
Taşınacak her iki boyutu da belirten bir POINT yapı veya CPoint nesne içerir.

size
Taşınacak her iki boyutu da belirten bir SIZE yapı veya CSize nesne içerir.

Açıklamalar

Birimleri x ekseni boyunca ve y birimleri y ekseni boyunca taşır.CRectx x ve y parametreleri imzalı değerlerdir, bu nedenle CRect sola veya sağa, yukarı veya aşağı taşınabilir.

Örnek

CRect rect(0, 0, 35, 35);
rect.OffsetRect(230, 230);

// rect is now (230, 230, 265, 265)
ASSERT(rect == CRect(230, 230, 265, 265));

`CRect::operator LPCRECT` bir'i `CRect` öğesine `LPCRECT`dönüştürür.

operator LPCRECT() const throw();

Açıklamalar

Bu işlevi kullandığınızda, adres (&) işlecine ihtiyacınız yoktur. Bu işleç, bir nesnesini bekleyen LPCRECTbir CRect işleve geçirdiğinizde otomatik olarak kullanılır.

`CRect::operator LPRECT`

bir'i CRect öğesine LPRECTdönüştürür.

operator LPRECT() throw();

Açıklamalar

Bu işlevi kullandığınızda, adres (&) işlecine ihtiyacınız yoktur. Bu işleç, bir nesnesini bekleyen LPRECTbir CRect işleve geçirdiğinizde otomatik olarak kullanılır.

Örnek

örneğine CRect::operator LPCRECTbakın.

`CRect::operator =`

srcRect öğesine CRectatar.

void operator=(const RECT& srcRect) throw();

Parametreler

srcRect
Kaynak dikdörtgene başvurur. veya CRectolabilirRECT.

Örnek

CRect rect(0, 0, 127, 168);
CRect rect2;

rect2 = rect;
ASSERT(rect2 == CRect(0, 0, 127, 168));

`CRect::operator ==`

Sol üst ve sağ alt köşelerinin koordinatlarını karşılaştırarak eşit CRect olup olmadığını rect belirler.

BOOL operator==(const RECT& rect) const throw();

Parametreler

rect
Kaynak dikdörtgene başvurur. veya CRectolabilirRECT.

Dönüş Değeri

Sıfır olmayan eşitse; aksi takdirde 0.

Açıklamalar

Not

Örnek

CRect rect1(35, 150, 10, 25);
CRect rect2(35, 150, 10, 25);
CRect rect3(98, 999, 6, 3);
ASSERT(rect1 == rect2);
// works just fine against RECTs, as well

RECT test;
test.left = 35;
test.top = 150;
test.right = 10;
test.bottom = 25;

ASSERT(rect1 == test);

`CRect::operator !=`

Sol üst ve sağ alt köşelerinin koordinatlarını karşılaştırarak eşit CRect olup olmadığını rect belirler.

BOOL operator!=(const RECT& rect) const throw();

Parametreler

rect
Kaynak dikdörtgene başvurur. veya CRectolabilirRECT.

Dönüş Değeri

Eşit değilse sıfır olmayan; aksi takdirde 0.

Açıklamalar

Not

Örnek

CRect rect1(35, 150, 10, 25);
CRect rect2(35, 150, 10, 25);
CRect rect3(98, 999,  6,  3);
ASSERT(rect1 != rect3);
// works just fine against RECTs, as well

RECT test;
test.left = 35;
test.top = 150;
test.right = 10;
test.bottom = 25;

ASSERT(rect3 != test);

`CRect::operator +=`

İlk iki aşırı yükleme, belirtilen uzaklıklara göre taşınır CRect .

void operator+=(POINT point) throw();
void operator+=(SIZE size) throw();
void operator+=(LPCRECT lpRect) throw();

Parametreler

point
POINT Dikdörtgenin taşınacak birim sayısını belirten bir yapı veya CPoint nesne.

size
SIZE Dikdörtgenin taşınacak birim sayısını belirten bir yapı veya CSize nesne.

lpRect
öğesinin her tarafını CRectşişirmek için birim sayısını içeren bir RECT yapıyı veya CRect nesneyi gösterir.

Açıklamalar

parametresinin x ve y (veya cx ve cy) değerleri öğesine CRecteklenir.

Üçüncü aşırı yükleme, parametrenin her üyesinde belirtilen birim sayısına göre şişirir CRect .

Örnek

CRect   rect1(100, 235, 200, 335);
CPoint  pt(35, 65);
CRect   rect2(135, 300, 235, 400);

rect1 += pt;
ASSERT(rect1 == rect2);

`CRect::operator -=`

İlk iki aşırı yükleme, belirtilen uzaklıklara göre taşınır CRect .

void operator-=(POINT point) throw();
void operator-=(SIZE size) throw();
void operator-=(LPCRECT lpRect) throw();

Parametreler

point
POINT Dikdörtgenin taşınacak birim sayısını belirten bir yapı veya CPoint nesne.

size
SIZE Dikdörtgenin taşınacak birim sayısını belirten bir yapı veya CSize nesne.

lpRect
öğesinin her tarafının söndürileceği birim sayısını içeren bir RECT yapıya veya CRect nesneye CRectişaret etti.

Açıklamalar

Parametrenin x ve y (veya cx ve cy) değerleri değerinden CRectçıkarılır.

Üçüncü aşırı yükleme, parametrenin her bir üyesinde belirtilen birim sayısına göre şişer CRect . Bu aşırı yüklemenin gibi DeflateRectçalıştığını unutmayın.

Örnek

CRect   rect1(100, 235, 200, 335);
CPoint pt(35, 65);

rect1 -= pt;
CRect   rectResult(65, 170, 165, 270);
ASSERT(rect1 == rectResult);

`CRect::operator &=`

ve rectkesişimine CRect eşit ayarlarCRect.

void operator&=(const RECT& rect) throw();

Parametreler

rect
RECT veya CRectiçerir.

Açıklamalar

Kesişim, her iki dikdörtgende de bulunan en büyük dikdörtgendir.

Not

Örnek

örneğine CRect::IntersectRectbakın.

`CRect::operator |=`

ve rectbirleşimine CRect eşit ayarlarCRect.

void operator|=(const RECT& rect) throw();

Parametreler

rect
CRect veya RECTiçerir.

Açıklamalar

Birleşim, her iki kaynak dikdörtgeni de içeren en küçük dikdörtgendir.

Not

Örnek

CRect   rect1(100,  0, 200, 300);
CRect   rect2(0, 100, 300, 200);

rect1 |= rect2;
CRect   rectResult(0, 0, 300, 300);
ASSERT(rectResult == rect1);

`CRect::operator +`

İlk iki aşırı yükleme, belirtilen uzaklıklar tarafından yerinden edilene CRect eşit bir CRect nesne döndürür.

CRect operator+(POINT point) const throw();
CRect operator+(LPCRECT lpRect) const throw();
CRect operator+(SIZE size) const throw();

Parametreler

point
POINT Dönüş değerinin taşınacak birim sayısını belirten bir yapı veya CPoint nesne.

size
SIZE Dönüş değerinin taşınacak birim sayısını belirten bir yapı veya CSize nesne.

lpRect
Dönüş değerinin her tarafını şişirmek için birim sayısını içeren bir RECT yapıyı veya CRect nesneyi gösterir.

Dönüş Değeri

CRect Parametresinde belirtilen birim sayısının taşınmasından veya şişirilmesinden CRect elde edilen sonuç.

Açıklamalar

parametresinin x ve y (veya cx ve cy) parametreleri 'nin konumuna CRecteklenir.

Üçüncü aşırı yükleme, parametrenin CRect her bir üyesinde belirtilen birim sayısıyla şişirilmiş olan yeni CRect bir değer döndürür.

Örnek

CRect   rect1(100, 235, 200, 335);
CPoint pt(35, 65);
CRect   rect2;

rect2 = rect1 + pt;
CRect   rectResult(135, 300, 235, 400);
ASSERT(rectResult == rect2);

`CRect::operator -`

İlk iki aşırı yükleme, belirtilen uzaklıklar tarafından yerinden edilene CRect eşit bir CRect nesne döndürür.

CRect operator-(POINT point) const throw();
CRect operator-(SIZE size) const throw();
CRect operator-(LPCRECT lpRect) const throw();

Parametreler

point
POINT Dönüş değerinin taşınacak birim sayısını belirten bir yapı veya CPoint nesne.

size
SIZE Dönüş değerinin taşınacak birim sayısını belirten bir yapı veya CSize nesne.

lpRect
Dönüş değerinin her tarafını söndürecek birim sayısını içeren bir RECT yapıya veya CRect nesneye işaret edin.

Dönüş Değeri

CRect Parametresinde belirtilen birim sayısına göre taşıma veya sönme CRect sonucu elde edilen.

Açıklamalar

Parametrenin x ve y (veya cx ve cy) parametreleri 'nin konumundan CRectçıkarılır.

Üçüncü aşırı yükleme, parametrenin her üyesinde belirtilen birim sayısıyla sönmeye CRect eşit bir yeni CRect döndürür. Bu aşırı yüklemenin yerine SubtractRectgibi DeflateRectçalıştığını unutmayın.

Örnek

CRect   rect1(100, 235, 200, 335);
CPoint pt(35, 65);
CRect   rect2;

rect2 = rect1 - pt;
CRect   rectResult(65, 170, 165, 270);
ASSERT(rect2 == rectResult);

`CRect::operator &`

ve rect2'ninCRect kesişimi olan bir CRect döndürür.

CRect operator&(const RECT& rect2) const throw();

Parametreler

rect2
RECT veya CRectiçerir.

Dönüş Değeri

CRect ve rect2'nin CRect kesişimi olan bir.

Açıklamalar

Kesişim, her iki dikdörtgende de bulunan en büyük dikdörtgendir.

Not

Örnek

CRect   rect1(100,  0, 200, 300);
CRect   rect2(0, 100, 300, 200);
CRect   rect3;

rect3 = rect1 & rect2;
CRect   rectResult(100, 100, 200, 200);
ASSERT(rectResult == rect3);

`CRect::operator |`

ve rect2birleşimi olan CRect bir CRect döndürür.

CRect operator|(const RECT&
rect2) const throw();

Parametreler

rect2
RECT veya CRectiçerir.

Dönüş Değeri

CRect ve rect2'nin CRect birleşimi olan bir.

Açıklamalar

Birleşim, her iki dikdörtgeni de içeren en küçük dikdörtgendir.

Not

Örnek

CRect   rect1(100,  0, 200, 300);
CRect   rect2(0, 100, 300, 200);
CRect   rect3;

rect3 = rect1 | rect2;
CRect   rectResult(0, 0, 300, 300);
ASSERT(rectResult == rect3);

`CRect::PtInRect`

Belirtilen noktanın içinde CRectolup olmadığını belirler.

BOOL PtInRect(POINT point) const throw();

Parametreler

point
Bir POINT yapı veya CPoint nesne içerir.

Dönüş Değeri

Nokta içindeyse CRectsıfır olmayan ; aksi takdirde 0.

Açıklamalar

Nokta, sol tarafta veya üst taraftaysa veya dört tarafın içindeyse içindedir CRect . Sağ veya alt taraftaki bir nokta dışındadır CRect.

Not

Dikdörtgen normalleştirilmelidir, aksi durumda bu işlev başarısız olabilir. Bu işlevi çağırmadan önce dikdörtgeni normalleştirmek için çağırabilirsiniz NormalizeRect .

Örnek

CRect rect(5, 5, 100, 100);
CPoint pt1(35, 50);
CPoint pt2(125, 298);

// this is true, because pt1 is inside the rectangle
ASSERT(rect.PtInRect(pt1));

// this is NOT true, because pt2 is outside the rectangle
ASSERT(!rect.PtInRect(pt2));

// note that the right and the bottom aren't inside
ASSERT(!rect.PtInRect(CPoint(35, 100)));
ASSERT(!rect.PtInRect(CPoint(100, 98)));

// but the top and the left are inside
ASSERT(rect.PtInRect(CPoint(5, 65)));
ASSERT(rect.PtInRect(CPoint(88, 5)));

// and that PtInRect() works against a POINT, too
POINT pt;
pt.x = 35;
pt.y = 50;
ASSERT(rect.PtInRect(pt));

`CRect::SetRect`

boyutlarını CRect belirtilen koordinatlara ayarlar.

void SetRect(int x1, int y1, int x2, int y2) throw();

Parametreler

x1
Sol üst köşenin x koordinatını belirtir.

y1
Sol üst köşenin y koordinatını belirtir.

x2
Sağ alt köşenin x koordinatını belirtir.

y2
Sağ alt köşenin y koordinatını belirtir.

Örnek

CRect rect;
rect.SetRect(256, 256, 512, 512);
ASSERT(rect == CRect(256, 256, 512, 512));

`CRect::SetRectEmpty`

Tüm koordinatları sıfır olarak ayarlayarak null dikdörtgen oluşturur CRect .

void SetRectEmpty() throw();

Örnek

CRect rect;
rect.SetRectEmpty();

// rect is now (0, 0, 0, 0)
ASSERT(rect.IsRectEmpty());

`CRect::SIZE`

cx dönüş değerinin ve cy üyeleri, yüksekliğini ve genişliğini CRectiçerir.

CSize Size() const throw();

Dönüş Değeri

CSize boyutunu CRectiçeren bir nesne.

Açıklamalar

Yükseklik veya genişlik negatif olabilir.

Not

Dikdörtgen normalleştirilmelidir, aksi durumda bu işlev başarısız olabilir. Bu işlevi çağırmadan önce dikdörtgeni normalleştirmek için çağırabilirsiniz NormalizeRect .

Örnek

CRect rect(10, 10, 50, 50);
CSize sz = rect.Size();
ASSERT(sz.cx == 40 && sz.cy == 40);

`CRect::SubtractRect`

boyutlarını' CRect dan lpRectSrc1çıkarma değerine lpRectSrc2 eşit hale getirir.

BOOL SubtractRect(LPCRECT lpRectSrc1, LPCRECT lpRectSrc2) throw();

Parametreler

lpRectSrc1
Bir dikdörtgenin RECT çıkarılacağı yapıyı veya CRect nesneyi gösterir.

lpRectSrc2
parametresi tarafından işaret edilen RECT dikdörtgenden çıkarılacak yapıyı lpRectSrc1 veya CRect nesneyi gösterir.

Dönüş Değeri

İşlev başarılı olursa sıfır dışında bir değer, aksi durumda 0.

Açıklamalar

Çıkarma, ve lpRectScr2kesişiminde olmayan tüm noktaları lpRectScr1 içeren en küçük dikdörtgendirlpRectScr1.

tarafından belirtilen dikdörtgen x veya y yönlerinden en az birinde tarafından lpRectSrc1 belirtilen dikdörtgenle tamamen çakışmazsalpRectSrc2, tarafından lpRectSrc1 belirtilen dikdörtgen değiştirilmez.

Örneğin, (10,10, 100,100) ve lpRectSrc2 (50,50, 150,150) iselpRectSrc1, işlevi döndürdüğnde tarafından lpRectSrc1 işaret edilen dikdörtgen değiştirilmez. Eğer (10,10, 100,100) ve lpRectSrc2 (50,10, 150,150) iselpRectSrc1, ancak tarafından lpRectSrc1 işaret edilen dikdörtgen işlevin döndüreceği koordinatları (10,10, 50,100) içerir.

SubtractRectişleç - veya işleci -=ile aynı değildir. Bu işleçlerden hiçbiri çağrı SubtractRectyapmaz.

Not

Örnek

RECT   rectOne;
RECT   rectTwo;

rectOne.left = 10;
rectOne.top = 10;
rectOne.bottom = 100;
rectOne.right = 100;

rectTwo.left = 50;
rectTwo.top = 10;
rectTwo.bottom = 150;
rectTwo.right = 150;

CRect   rectDiff;

rectDiff.SubtractRect(&rectOne, &rectTwo);
CRect   rectResult(10, 10, 50, 100);

ASSERT(rectDiff == rectResult);

// works for CRect, too, since there is
// implicit CRect -> LPCRECT conversion

CRect rect1(10, 10, 100, 100);
CRect rect2(50, 10, 150, 150);
CRect rectOut;

rectOut.SubtractRect(rect1, rect2);
ASSERT(rectResult == rectOut);

`CRect::TopLeft`

Koordinatlar içinde bulunan CRectbir CPoint nesneye başvuru olarak döndürülür.

CPoint& TopLeft() throw();
const CPoint& TopLeft() const throw();

Dönüş Değeri

Dikdörtgenin sol üst köşesinin koordinatları.

Açıklamalar

Dikdörtgenin sol üst köşesini almak veya ayarlamak için bu işlevi kullanabilirsiniz. Atama işlecinin sol tarafındaki bu işlevi kullanarak köşeyi ayarlayın.

Örnek

örneğine CRect::CenterPointbakın.

`CRect::UnionRect`

boyutlarını CRect iki kaynak dikdörtgenin birleşimine eşit hale getirir.

BOOL UnionRect(LPCRECT lpRect1, LPCRECT lpRect2) throw();

Parametreler

lpRect1
Kaynak dikdörtgen içeren veya RECT CRect öğesini gösterir.

lpRect2
Kaynak dikdörtgen içeren veya RECT CRect öğesini gösterir.

Dönüş Değeri

Birleşim boş değilse sıfır olmayan; Birleşim boşsa 0.

Açıklamalar

Birleşim, her iki kaynak dikdörtgeni de içeren en küçük dikdörtgendir.

Windows boş bir dikdörtgenin boyutlarını yoksayar; başka bir ifadeyle, yüksekliği olmayan veya genişliği olmayan bir dikdörtgen.

Not

Örnek

CRect   rect1(100,  0, 200, 300);
CRect   rect2(0, 100, 300, 200);
CRect   rect3;

rect3.UnionRect(&rect1, &rect2);
CRect   rectResult(0, 0, 300, 300);
ASSERT(rectResult == rect3);

`CRect::Width`

Sol değeri sağ değerden çıkararak genişliğini CRect hesaplar.

int Width() const throw();

Dönüş Değeri

genişliği CRect.

Açıklamalar

Genişlik negatif olabilir.

Not

Dikdörtgen normalleştirilmelidir, aksi durumda bu işlev başarısız olabilir. Bu işlevi çağırmadan önce dikdörtgeni normalleştirmek için çağırabilirsiniz NormalizeRect .

Örnek

CRect rect(20, 30, 80, 70);
int nWid = rect.Width();
// nWid is now 60
ASSERT(nWid == 60);

Ayrıca bkz.

CPoint Sınıf
CSize Sınıf
RECT

Aracılığıyla paylaş

CRect Sınıf

Sözdizimi

Üyeler

Ortak Oluşturucular

Genel Yöntemler

Ortak İşleçler

Açıklamalar

Devralma Hiyerarşisi

Gereksinimler

CRect::BottomRight

Dönüş Değeri

Açıklamalar

Örnek

CRect::CenterPoint

Dönüş Değeri

Örnek

CRect::CopyRect

Parametreler

Örnek

CRect::CRect

Parametreler

Açıklamalar

Örnek

CRect::DeflateRect

Parametreler

Açıklamalar

Örnek

CRect::EqualRect

Parametreler

Dönüş Değeri

Örnek

CRect::Height

Dönüş Değeri

Açıklamalar

Örnek

CRect::InflateRect

Parametreler

Açıklamalar

Örnek

CRect::IntersectRect

Parametreler

Dönüş Değeri

Açıklamalar

Örnek

CRect::IsRectEmpty

Dönüş Değeri

Açıklamalar

Örnek

CRect::IsRectNull

Dönüş Değeri

Açıklamalar

Örnek

CRect::MoveToX

Parametreler

Örnek

CRect::MoveToXY

Parametreler

Örnek

CRect::MoveToY

Parametreler

Örnek

CRect::NormalizeRect

Açıklamalar

Örnek

CRect::OffsetRect

Parametreler

Açıklamalar

Örnek

CRect::operator LPCRECT bir'i CRect öğesine LPCRECTdönüştürür.

Açıklamalar

CRect::operator LPRECT

Açıklamalar

Örnek

CRect::operator =

Parametreler

Örnek

CRect::operator ==

Parametreler

Dönüş Değeri

`CRect` Sınıf

`CRect::BottomRight`

`CRect::CenterPoint`

`CRect::CopyRect`

`CRect::CRect`

`CRect::DeflateRect`

`CRect::EqualRect`

`CRect::Height`

`CRect::InflateRect`

`CRect::IntersectRect`

`CRect::IsRectEmpty`

`CRect::IsRectNull`

`CRect::MoveToX`

`CRect::MoveToXY`

`CRect::MoveToY`

`CRect::NormalizeRect`

`CRect::OffsetRect`

`CRect::operator LPCRECT` bir'i `CRect` öğesine `LPCRECT`dönüştürür.

`CRect::operator LPRECT`

`CRect::operator =`

`CRect::operator ==`

`CRect::operator !=`

`CRect::operator +=`

`CRect::operator -=`

`CRect::operator &=`

`CRect::operator |=`

`CRect::operator +`

`CRect::operator -`

`CRect::operator &`

`CRect::operator |`

`CRect::PtInRect`

`CRect::SetRect`

`CRect::SetRectEmpty`

`CRect::SIZE`

`CRect::SubtractRect`

`CRect::TopLeft`

`CRect::UnionRect`