ReactOS  0.4.13-dev-242-g611e6d7
atltypes.h
Go to the documentation of this file.
1 /*
2  * ReactOS ATL
3  *
4  * Copyright 2016 Mark Jansen
5  *
6  * This library is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * This library is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with this library; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19  */
20 
21 #pragma once
22 
23 
24 class CSize;
25 class CRect;
26 
27 
28 class CPoint : public tagPOINT
29 {
30 public:
31 
32  CPoint() throw()
33  {
34  x = y = 0;
35  }
36 
37  CPoint(int initX, int initY) throw()
38  {
39  x = initX;
40  y = initY;
41  }
42 
43  CPoint(POINT initPt) throw()
44  {
45  *((POINT*)this) = initPt;
46  }
47 
48  CPoint(SIZE initSize) throw()
49  {
50  *((SIZE*)this) = initSize;
51  }
52 
53  CPoint(LPARAM dwPoint) throw()
54  {
55  x = LOWORD(dwPoint);
56  y = HIWORD(dwPoint);
57  }
58 
59  void Offset(int xOffset, int yOffset) throw()
60  {
61  x += xOffset;
62  y += yOffset;
63  }
64 
65  void Offset(POINT point) throw()
66  {
67  Offset(point.x, point.y);
68  }
69 
70  void Offset(SIZE size) throw()
71  {
72  Offset(size.cx, size.cy);
73  }
74 
75  BOOL operator==(POINT point) const throw()
76  {
77  return (x == point.x && y == point.y);
78  }
79 
80  BOOL operator!=(POINT point) const throw()
81  {
82  return !(*this == point);
83  }
84 
85  void operator+=(SIZE size) throw()
86  {
87  Offset(size);
88  }
89 
90  void operator+=(POINT point) throw()
91  {
92  Offset(point);
93  }
94 
95  void operator-=(SIZE size) throw()
96  {
97  Offset(-size.cx, -size.cy);
98  }
99 
100  void operator-=(POINT point) throw()
101  {
102  Offset(-point.x, -point.y);
103  }
104 
105  CPoint operator+(SIZE size) const throw()
106  {
107  return CPoint(x + size.cx, y + size.cy);
108  }
109 
110  CPoint operator+(POINT point) const throw()
111  {
112  return CPoint(x + point.x, y + point.y);
113  }
114 
115  CRect operator+(const RECT* lpRect) const throw();
116 
117  CSize operator-(POINT point) const throw();
118 
119  CPoint operator-(SIZE size) const throw()
120  {
121  return CPoint(x - size.cx, y - size.cy);
122  }
123 
124  CRect operator-(const RECT* lpRect) const throw();
125 
126  CPoint operator-() const throw()
127  {
128  return CPoint(-x, -y);
129  }
130 };
131 
132 class CSize : public tagSIZE
133 {
134 public:
135  CSize() throw()
136  {
137  cx = cy = 0;
138  }
139 
140  CSize(int initCX, int initCY) throw()
141  {
142  cx = initCX;
143  cy = initCY;
144  }
145 
146  CSize(SIZE initSize) throw()
147  {
148  *((SIZE*)this) = initSize;
149  }
150 
151  CSize(POINT initPt) throw()
152  {
153  *((POINT*)this) = initPt;
154  }
155 
156  CSize(DWORD dwSize) throw()
157  {
158  cx = LOWORD(dwSize);
159  cy = HIWORD(dwSize);
160  }
161 
162  BOOL operator==(SIZE size) const throw()
163  {
164  return (size.cx == cx && size.cy == cy);
165  }
166 
167  BOOL operator!=(SIZE size) const throw()
168  {
169  return !(*this == size);
170  }
171 
172  void operator+=(SIZE size) throw()
173  {
174  cx += size.cx;
175  cy += size.cy;
176  }
177 
178  void operator-=(SIZE size) throw()
179  {
180  cx -= size.cx;
181  cy -= size.cy;
182  }
183 
184  CSize operator+(SIZE size) const throw()
185  {
186  return CSize(cx + size.cx, cy + size.cy);
187  }
188 
189  CPoint operator+(POINT point) const throw()
190  {
191  return CPoint(cx + point.x, cy + point.y);
192  }
193 
194  CRect operator+(const RECT* lpRect) const throw();
195 
196  CSize operator-(SIZE size) const throw()
197  {
198  return CSize(cx - size.cx, cy - size.cy);
199  }
200 
201  CPoint operator-(POINT point) const throw()
202  {
203  return CPoint(cx - point.x, cy - point.y);
204  }
205 
206  CRect operator-(const RECT* lpRect) const throw();
207 
208  CSize operator-() const throw()
209  {
210  return CSize(-cx, -cy);
211  }
212 };
213 
214 
216 {
217  return CSize(x - point.x, y - point.y);
218 }
219 
220 
221 class CRect : public tagRECT
222 {
223 public:
224  CRect() throw()
225  {
226  left = top = right = bottom = 0;
227  }
228 
229  CRect(int l, int t, int r, int b) throw()
230  {
231  left = l;
232  top = t;
233  right = r;
234  bottom = b;
235  }
236 
237  CRect(const RECT& srcRect) throw()
238  {
239  left = srcRect.left;
240  top = srcRect.top;
241  right = srcRect.right;
242  bottom = srcRect.bottom;
243  }
244 
245  CRect(LPCRECT lpSrcRect) throw()
246  {
247  left = lpSrcRect->left;
248  top = lpSrcRect->top;
249  right = lpSrcRect->right;
250  bottom = lpSrcRect->bottom;
251  }
252 
254  {
255  left = point.x;
256  top = point.y;
257  right = point.x + size.cx;
258  bottom = point.y + size.cy;
259  }
260 
261  CRect(POINT topLeft, POINT bottomRight) throw()
262  {
263  left = topLeft.x;
264  top = topLeft.y;
265  right = bottomRight.x;
266  bottom = bottomRight.y;
267  }
268 
269  CPoint& BottomRight() throw()
270  {
271  return ((CPoint*)this)[1];
272  }
273 
274  const CPoint& BottomRight() const throw()
275  {
276  return ((const CPoint*)this)[1];
277  }
278 
279  CPoint CenterPoint() const throw()
280  {
281  return CPoint(left + (Width() >> 1), top + (Height() >> 1));
282  }
283 
284  void CopyRect(LPCRECT lpSrcRect) throw()
285  {
286  ::CopyRect(this, lpSrcRect);
287  }
288 
289  void DeflateRect(int x, int y) throw()
290  {
291  ::InflateRect(this, -x, -y);
292  }
293 
294  void DeflateRect(SIZE size) throw()
295  {
296  ::InflateRect(this, -size.cx, -size.cy);
297  }
298 
299  void DeflateRect(LPCRECT lpRect) throw()
300  {
301  DeflateRect(lpRect->left, lpRect->top, lpRect->right, lpRect->bottom);
302  }
303 
304  void DeflateRect(int l, int t, int r, int b) throw()
305  {
306  left += l;
307  top += t;
308  right -= r;
309  bottom -= b;
310  }
311 
312  BOOL EqualRect(LPCRECT lpRect) const throw()
313  {
314  return ::EqualRect(this, lpRect);
315  }
316 
317 
318  int Height() const throw()
319  {
320  return bottom - top;
321  }
322 
323  void InflateRect(int x, int y) throw()
324  {
325  ::InflateRect(this, x, y);
326  }
327 
328  void InflateRect(SIZE size) throw()
329  {
330  ::InflateRect(this, size.cx, size.cy);
331  }
332 
333  void InflateRect(LPCRECT lpRect) throw()
334  {
335  InflateRect(lpRect->left, lpRect->top, lpRect->right, lpRect->bottom);
336  }
337 
338  void InflateRect(int l, int t, int r, int b) throw()
339  {
340  left -= l;
341  top -= t;
342  right += r;
343  bottom += b;
344  }
345 
346  BOOL IntersectRect(LPCRECT lpRect1, LPCRECT lpRect2) throw()
347  {
348  return ::IntersectRect(this, lpRect1, lpRect2);
349  }
350 
351  BOOL IsRectEmpty() const throw()
352  {
353  return ::IsRectEmpty(this);
354  }
355 
356  BOOL IsRectNull() const throw()
357  {
358  return (left == 0 && right == 0 &&
359  top == 0 && bottom == 0);
360  }
361 
362  //void MoveToX(int x) throw()
363  //void MoveToXY(int x, int y) throw()
364  //void MoveToXY(POINT point) throw()
365  //void MoveToY(int y) throw()
366  //void NormalizeRect() throw()
367 
368  void OffsetRect(int x, int y) throw()
369  {
370  ::OffsetRect(this, x, y);
371  }
372 
373  void OffsetRect(POINT point) throw()
374  {
375  ::OffsetRect(this, point.x, point.y);
376  }
377 
378  void OffsetRect(SIZE size) throw()
379  {
380  ::OffsetRect(this, size.cx, size.cy);
381  }
382 
383  //BOOL PtInRect(POINT point) const throw()
384  //void SetRect(int x1, int y1, int x2, int y2) throw()
385  //void SetRectEmpty() throw()
386  //CSize Size() const throw()
387  //BOOL SubtractRect(LPCRECT lpRectSrc1, LPCRECT lpRectSrc2) throw()
388 
389  CPoint& TopLeft() throw()
390  {
391  return ((CPoint*)this)[0];
392  }
393 
394  const CPoint& TopLeft() const throw()
395  {
396  return ((const CPoint*)this)[0];
397  }
398 
399  BOOL UnionRect(LPCRECT lpRect1, LPCRECT lpRect2) throw()
400  {
401  return ::UnionRect(this, lpRect1, lpRect2);
402  }
403 
404  int Width() const throw()
405  {
406  return right - left;
407  }
408 
409 
410  BOOL operator==(const RECT& rect) const throw()
411  {
412  return (left == rect.left &&
413  top == rect.top &&
414  right == rect.right &&
415  bottom == rect.bottom);
416  }
417 
418  BOOL operator!=(const RECT& rect) const throw()
419  {
420  return !(*this == rect);
421  }
422 
423  void operator=(const RECT& srcRect) throw()
424  {
425  left = srcRect.left;
426  top = srcRect.top;
427  right = srcRect.right;
428  bottom = srcRect.bottom;
429  }
430 
431  void operator+=(POINT point) throw()
432  {
433  OffsetRect(point);
434  }
435 
436  void operator+=(SIZE size) throw()
437  {
438  OffsetRect(size);
439  }
440 
441  void operator+=(LPCRECT lpRect) throw()
442  {
443  InflateRect(lpRect);
444  }
445 
446  void operator-=(POINT point) throw()
447  {
448  OffsetRect(-point.x, -point.y);
449  }
450 
451  void operator-=(SIZE size) throw()
452  {
453  OffsetRect(-size.cx, -size.cy);
454  }
455 
456  void operator-=(LPCRECT lpRect) throw()
457  {
458  DeflateRect(lpRect);
459  }
460 
461 
462  CRect operator+(POINT point) const throw()
463  {
464  CRect r(this);
465  r.OffsetRect(point);
466  return r;
467  }
468 
469  CRect operator+(LPCRECT lpRect) const throw()
470  {
471  CRect r(this);
472  r.InflateRect(lpRect);
473  return r;
474  }
475 
476  CRect operator+(SIZE size) const throw()
477  {
478  CRect r(this);
479  r.OffsetRect(size);
480  return r;
481  }
482 
483  CRect operator-(POINT point) const throw()
484  {
485  CRect r(this);
486  r.OffsetRect(-point.x, -point.y);
487  return r;
488  }
489 
490  CRect operator-(SIZE size) const throw()
491  {
492  CRect r(this);
493  r.OffsetRect(-size.cx, -size.cy);
494  return r;
495  }
496 
497  CRect operator-(LPCRECT lpRect) const throw()
498  {
499  CRect r(this);
500  r.DeflateRect(lpRect);
501  return r;
502  }
503 
504  void operator&=(const RECT& rect) throw()
505  {
506  IntersectRect(this, &rect);
507  }
508 
509  CRect operator&(const RECT& rect2) const throw()
510  {
511  CRect r;
512  r.IntersectRect(this, &rect2);
513  return r;
514  }
515 
516  void operator|=(const RECT& rect) throw()
517  {
518  UnionRect(this, &rect);
519  }
520 
521  CRect operator|(const RECT& rect2) const throw()
522  {
523  CRect r;
524  r.UnionRect(this, &rect2);
525  return r;
526  }
527 
528  operator LPRECT() throw()
529  {
530  return this;
531  }
532 
533  operator LPCRECT() const throw()
534  {
535  return this;
536  }
537 };
538 
539 CRect CPoint::operator+(const RECT* lpRect) const throw()
540 {
541  CRect r(lpRect);
542  r += *this;
543  return r;
544 }
545 
546 CRect CPoint::operator-(const RECT* lpRect) const throw()
547 {
548  CRect r(lpRect);
549  r -= *this;
550  return r;
551 }
552 
553 CRect CSize::operator+(const RECT* lpRect) const throw()
554 {
555  CRect r(lpRect);
556  r += *this;
557  return r;
558 }
559 
560 CRect CSize::operator-(const RECT* lpRect) const throw()
561 {
562  CRect r(lpRect);
563  r -= *this;
564  return r;
565 }
566 
BOOL UnionRect(LPCRECT lpRect1, LPCRECT lpRect2)
Definition: atltypes.h:399
CPoint(int initX, int initY)
Definition: atltypes.h:37
const CPoint & BottomRight() const
Definition: atltypes.h:274
RECT rect2
Definition: edittest.c:51
CPoint(SIZE initSize)
Definition: atltypes.h:48
void DeflateRect(int l, int t, int r, int b)
Definition: atltypes.h:304
CPoint & BottomRight()
Definition: atltypes.h:269
void InflateRect(int x, int y)
Definition: atltypes.h:323
void InflateRect(LPCRECT lpRect)
Definition: atltypes.h:333
CRect(POINT topLeft, POINT bottomRight)
Definition: atltypes.h:261
BOOL operator==(POINT point) const
Definition: atltypes.h:75
int Width() const
Definition: atltypes.h:404
void OffsetRect(SIZE size)
Definition: atltypes.h:378
CSize operator+(SIZE size) const
Definition: atltypes.h:184
CPoint & TopLeft()
Definition: atltypes.h:389
CRect operator-(LPCRECT lpRect) const
Definition: atltypes.h:497
void operator+=(LPCRECT lpRect)
Definition: atltypes.h:441
GLdouble GLdouble GLdouble r
Definition: gl.h:2055
void OffsetRect(POINT point)
Definition: atltypes.h:373
CPoint(POINT initPt)
Definition: atltypes.h:43
CRect(const RECT &srcRect)
Definition: atltypes.h:237
CSize(DWORD dwSize)
Definition: atltypes.h:156
LONG top
Definition: windef.h:292
GLdouble GLdouble t
Definition: gl.h:2047
BOOL operator==(const RECT &rect) const
Definition: atltypes.h:410
GLint GLint GLint GLint GLint x
Definition: gl.h:1548
void operator+=(SIZE size)
Definition: atltypes.h:436
CSize(SIZE initSize)
Definition: atltypes.h:146
LONG left
Definition: windef.h:291
void CopyRect(LPCRECT lpSrcRect)
Definition: atltypes.h:284
POINTL point
Definition: edittest.c:50
& rect
Definition: startmenu.cpp:1413
CPoint operator+(SIZE size) const
Definition: atltypes.h:105
LONG y
Definition: windef.h:315
CPoint operator+(POINT point) const
Definition: atltypes.h:189
void DeflateRect(SIZE size)
Definition: atltypes.h:294
void DeflateRect(LPCRECT lpRect)
Definition: atltypes.h:299
CRect operator+(POINT point) const
Definition: atltypes.h:462
BOOL operator!=(SIZE size) const
Definition: atltypes.h:167
unsigned int BOOL
Definition: ntddk_ex.h:94
BOOL operator==(SIZE size) const
Definition: atltypes.h:162
CSize(int initCX, int initCY)
Definition: atltypes.h:140
BOOL WINAPI IsRectEmpty(_In_ LPCRECT)
void operator-=(SIZE size)
Definition: atltypes.h:95
LONG cx
Definition: windef.h:319
LONG_PTR LPARAM
Definition: windef.h:208
#define LPRECT
Definition: precomp.h:28
GLint GLint bottom
Definition: glext.h:7726
BOOL operator!=(POINT point) const
Definition: atltypes.h:80
BOOL IsRectEmpty() const
Definition: atltypes.h:351
CRect(int l, int t, int r, int b)
Definition: atltypes.h:229
#define b
Definition: ke_i.h:79
int Height() const
Definition: atltypes.h:318
void operator=(const RECT &srcRect)
Definition: atltypes.h:423
r l[0]
Definition: byte_order.h:167
BOOL IntersectRect(LPCRECT lpRect1, LPCRECT lpRect2)
Definition: atltypes.h:346
void operator+=(POINT point)
Definition: atltypes.h:431
CPoint(LPARAM dwPoint)
Definition: atltypes.h:53
GLboolean GLboolean GLboolean b
Definition: glext.h:6204
CRect operator+(SIZE size) const
Definition: atltypes.h:476
GLsizeiptr size
Definition: glext.h:5919
void Offset(SIZE size)
Definition: atltypes.h:70
CRect(POINT point, SIZE size)
Definition: atltypes.h:253
void DeflateRect(int x, int y)
Definition: atltypes.h:289
CRect operator-(SIZE size) const
Definition: atltypes.h:490
void InflateRect(SIZE size)
Definition: atltypes.h:328
#define LPCRECT
Definition: precomp.h:29
BOOL operator!=(const RECT &rect) const
Definition: atltypes.h:418
CPoint operator-(POINT point) const
Definition: atltypes.h:201
void operator&=(const RECT &rect)
Definition: atltypes.h:504
CPoint CenterPoint() const
Definition: atltypes.h:279
void Offset(POINT point)
Definition: atltypes.h:65
unsigned long DWORD
Definition: ntddk_ex.h:95
GLint left
Definition: glext.h:7726
LONG x
Definition: windef.h:314
BOOL WINAPI UnionRect(_Out_ LPRECT, _In_ LPCRECT, _In_ LPCRECT)
CRect operator &(const RECT &rect2) const
Definition: atltypes.h:509
void operator-=(POINT point)
Definition: atltypes.h:100
GLdouble GLdouble right
Definition: glext.h:10859
void operator-=(SIZE size)
Definition: atltypes.h:178
void OffsetRect(int x, int y)
Definition: atltypes.h:368
CPoint operator-(SIZE size) const
Definition: atltypes.h:119
void operator+=(SIZE size)
Definition: atltypes.h:85
void operator-=(POINT point)
Definition: atltypes.h:446
void InflateRect(int l, int t, int r, int b)
Definition: atltypes.h:338
BOOL WINAPI IntersectRect(_Out_ LPRECT, _In_ LPCRECT, _In_ LPCRECT)
CSize operator-() const
Definition: atltypes.h:208
void operator|=(const RECT &rect)
Definition: atltypes.h:516
void operator-=(SIZE size)
Definition: atltypes.h:451
void Offset(int xOffset, int yOffset)
Definition: atltypes.h:59
const CPoint & TopLeft() const
Definition: atltypes.h:394
CRect operator-(POINT point) const
Definition: atltypes.h:483
CSize(POINT initPt)
Definition: atltypes.h:151
BOOL WINAPI EqualRect(_In_ LPCRECT, _In_ LPCRECT)
CPoint operator-() const
Definition: atltypes.h:126
void operator+=(SIZE size)
Definition: atltypes.h:172
CSize()
Definition: atltypes.h:135
int xOffset
Definition: appswitch.c:59
CRect operator+(LPCRECT lpRect) const
Definition: atltypes.h:469
CSize operator-(SIZE size) const
Definition: atltypes.h:196
GLint GLint GLint GLint GLint GLint y
Definition: gl.h:1548
CPoint()
Definition: atltypes.h:32
void operator-=(LPCRECT lpRect)
Definition: atltypes.h:456
BOOL IsRectNull() const
Definition: atltypes.h:356
#define HIWORD(l)
Definition: typedefs.h:246
BOOL EqualRect(LPCRECT lpRect) const
Definition: atltypes.h:312
int yOffset
Definition: appswitch.c:59
GLdouble GLdouble GLdouble GLdouble top
Definition: glext.h:10859
CPoint operator+(POINT point) const
Definition: atltypes.h:110
void operator+=(POINT point)
Definition: atltypes.h:90
CRect operator|(const RECT &rect2) const
Definition: atltypes.h:521
LONG cy
Definition: windef.h:320
CRect()
Definition: atltypes.h:224
#define LOWORD(l)
Definition: pedump.c:82
PSDBQUERYRESULT_VISTA PVOID DWORD * dwSize
Definition: env.c:54
CRect(LPCRECT lpSrcRect)
Definition: atltypes.h:245