research/transmission_spectroscopy/TOF/Win32++/include/winutils.h

   1 // Win32++   Version 7.3\r
   2 // Released: 30th November 2011\r
   3 //\r
   4 //      David Nash\r
   5 //      email: [email protected]\r
   6 //      url: https://sourceforge.net/projects/win32-framework\r
   7 //\r
   8 //\r
   9 // Copyright (c) 2005-2011  David Nash\r
  10 //\r
  11 // Permission is hereby granted, free of charge, to\r
  12 // any person obtaining a copy of this software and\r
  13 // associated documentation files (the "Software"),\r
  14 // to deal in the Software without restriction, including\r
  15 // without limitation the rights to use, copy, modify,\r
  16 // merge, publish, distribute, sublicense, and/or sell\r
  17 // copies of the Software, and to permit persons to whom\r
  18 // the Software is furnished to do so, subject to the\r
  19 // following conditions:\r
  20 //\r
  21 // The above copyright notice and this permission notice\r
  22 // shall be included in all copies or substantial portions\r
  23 // of the Software.\r
  24 //\r
  25 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF\r
  26 // ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED\r
  27 // TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A\r
  28 // PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT\r
  29 // SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR\r
  30 // ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN\r
  31 // ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\r
  32 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE\r
  33 // OR OTHER DEALINGS IN THE SOFTWARE.\r
  34 //\r
  35 ////////////////////////////////////////////////////////\r
  36 \r
  37 #ifndef _WIN32XX_WINUTILS_H_\r
  38 #define _WIN32XX_WINUTILS_H_\r
  39 \r
  40 \r
  41 // define useful macros from WindowsX.h\r
  42 #ifndef GET_X_LPARAM\r
  43   #define GET_X_LPARAM(lp)  ((int)(short)LOWORD(lp))\r
  44 #endif\r
  45 #ifndef GET_Y_LPARAM\r
  46   #define GET_Y_LPARAM(lp)  ((int)(short)HIWORD(lp))\r
  47 #endif\r
  48 \r
  49 // Define our own MIN and MAX macros\r
  50 // this avoids inconsistencies with Dev-C++ and other compilers, and\r
  51 // avoids conflicts between typical min/max macros and std::min/std::max\r
  52 #define MAX(a,b)            (((a) > (b)) ? (a) : (b))\r
  53 #define MIN(a,b)            (((a) < (b)) ? (a) : (b))\r
  54 \r
  55 \r
  56 namespace Win32xx\r
  57 {\r
  58         // Forward declarations\r
  59         class CPoint;\r
  60         class CRect;\r
  61         CWinApp* GetApp();\r
  62         void TRACE(LPCTSTR str);\r
  63 \r
  64 \r
  65         /////////////////////////////////////////\r
  66         // Definition of the CSize class\r
  67         // This class can be used to replace the SIZE structure\r
  68         class CSize : public SIZE\r
  69         {\r
  70         public:\r
  71                 CSize()                                                         { cx = 0; cy = 0; }\r
  72                 CSize(int CX, int CY)                           { cx = CX; cy = CY; }\r
  73                 CSize(SIZE sz)                                          { cx = sz.cx; cy = sz.cy; }\r
  74                 CSize(POINT pt)                                         { cx = pt.x;  cy = pt.y; }\r
  75                 CSize(DWORD dw)                                         { cx = (short)LOWORD(dw); cy = (short)HIWORD(dw); }\r
  76                 void SetSize(int CX, int CY)            { cx = CX; cy = CY; }\r
  77 \r
  78                 // Operators\r
  79                 operator LPSIZE()                                       { return this; }\r
  80                 BOOL operator == (SIZE sz) const        { return (cx == sz.cx && cy == sz.cy); }\r
  81                 BOOL operator != (SIZE sz) const        { return (cx != sz.cx || cy != sz.cy); }\r
  82                 void operator += (SIZE sz)                      { cx += sz.cx; cy += sz.cy; }\r
  83                 void operator -= (SIZE sz)                      { cx -= sz.cx; cy -= sz.cy; }\r
  84 \r
  85                 // Operators returning CSize\r
  86                 CSize operator - () const                       { return CSize (-cx, -cy); }\r
  87                 CSize operator + (SIZE sz) const        { return CSize (cx + sz.cx, cy + sz.cy); }\r
  88                 CSize operator - (SIZE sz) const        { return CSize (cx - sz.cx, cy - sz.cy); }\r
  89 \r
  90                 // Operators returning CPoint\r
  91                 CPoint operator + (POINT point) const;\r
  92                 CPoint operator - (POINT point) const;\r
  93 \r
  94                 // Operators returning CRect\r
  95                 CRect operator + (RECT rc) const;\r
  96                 CRect operator - (RECT rc) const;\r
  97         };\r
  98 \r
  99 \r
 100         /////////////////////////////////////////\r
 101         // Definition of the CPoint class\r
 102         // This class can be used to replace the POINT structure\r
 103         class CPoint : public POINT\r
 104         {\r
 105         public:\r
 106                 CPoint()                                                        { x = 0; y = 0; }\r
 107                 CPoint(int X, int Y)                            { x = X; y = Y; }\r
 108                 CPoint(POINT pt)                                        { x = pt.x ; y = pt.y; }\r
 109                 CPoint(POINTS pts)                                      { x = pts.x; y = pts.y; }\r
 110                 CPoint(SIZE sz)                                         { x = sz.cx; y = sz.cy; }\r
 111                 CPoint(DWORD dw)                                        { x = (short) LOWORD(dw); y = (short) HIWORD(dw); }\r
 112 \r
 113                 void Offset(int dx, int dy)                     { x += dx; y += dy; }\r
 114                 void Offset(POINT pt)                           { x += pt.x; y += pt.y; }\r
 115                 void Offset(SIZE sz)                            { x += sz.cx; y += sz.cy; }\r
 116                 void SetPoint(int X, int Y)                     { x = X; y = Y; }\r
 117 \r
 118                 // Operators\r
 119                 operator LPPOINT()                                      { return this; }\r
 120                 BOOL operator == (POINT pt) const       { return ((x == pt.x) && (y == pt.y)); }\r
 121                 BOOL operator != (POINT pt) const       { return ((x != pt.x) || (y != pt.y)); }\r
 122                 void operator += (SIZE sz)                      { x += sz.cx; y += sz.cy; }\r
 123                 void operator -= (SIZE sz)                      { x -= sz.cx; y -= sz.cy; }\r
 124                 void operator += (POINT pt)                     { x += pt.x; y += pt.y; }\r
 125                 void operator -= (POINT pt)                     { x -= pt.x; y -= pt.y; }\r
 126 \r
 127                 // Operators returning CPoint\r
 128                 CPoint operator - () const                      { return CPoint(-x, -y); }\r
 129                 CPoint operator + (SIZE sz) const       { return CPoint(x + sz.cx, y + sz.cy); }\r
 130                 CPoint operator - (SIZE sz) const       { return CPoint(x - sz.cx, y - sz.cy); }\r
 131                 CPoint operator + (POINT pt) const      { return CPoint(x + pt.x, y + pt.y); }\r
 132                 CPoint operator - (POINT pt) const      { return CPoint(x - pt.x, y - pt.y); }\r
 133 \r
 134                 // Operators returning CRect\r
 135                 CRect operator + (RECT rc) const;\r
 136                 CRect operator - (RECT rc) const;\r
 137         };\r
 138 \r
 139 \r
 140         /////////////////////////////////////////\r
 141         // Definition of the CRect class\r
 142         // This class can be used to replace the RECT structure.\r
 143         class CRect : public RECT\r
 144         {\r
 145         public:\r
 146                 CRect()                                                                         { left = top = right = bottom = 0; }\r
 147                 CRect(int l, int t, int r, int b)                       { left = l; top = t; right = r; bottom = b; }\r
 148                 CRect(RECT rc)                                                          { left = rc.left; top = rc.top; right = rc.right; bottom = rc.bottom; }\r
 149                 CRect(POINT pt, SIZE sz)                                        { right = (left = pt.x) + sz.cx; bottom = (top = pt.y) + sz.cy; }\r
 150                 CRect(POINT topLeft, POINT bottomRight)         { left = topLeft.x; top = topLeft.y; right = bottomRight.x; bottom = bottomRight.y; }\r
 151 \r
 152                 BOOL CopyRect(RECT rc)                                          { return ::CopyRect(this, &rc); }\r
 153                 BOOL DeflateRect(int x, int y)                          { return ::InflateRect(this, -x, -y); }\r
 154                 BOOL DeflateRect(SIZE size)                                     { return ::InflateRect(this, -size.cx, -size.cy); }\r
 155                 BOOL DeflateRect(RECT rc)                                       { return ::InflateRect(this, rc.left - rc.right, rc.top - rc.bottom); }\r
 156                 BOOL DeflateRect(int l, int t, int r, int b){ return ::InflateRect(this, l - r, t - b); }\r
 157                 BOOL EqualRect(RECT rc) const                           { return ::EqualRect(&rc, this); }\r
 158                 BOOL InflateRect(int dx, int dy)                        { return ::InflateRect(this, dx, dy); }\r
 159                 BOOL InflateRect(SIZE sz)                                       { return ::InflateRect(this, sz.cx, sz.cy); }\r
 160                 BOOL InflateRect(RECT rc)                                       { return ::InflateRect(this, rc.right - rc.left, rc.bottom - rc.top); }\r
 161                 BOOL InflateRect(int l, int t, int r, int b){ return ::InflateRect(this, r - l, b - t); }\r
 162                 BOOL IntersectRect(RECT rc1, RECT rc2)          { return ::IntersectRect(this, &rc1, &rc2); }\r
 163                 BOOL IsRectEmpty() const                                        { return ::IsRectEmpty(this);}\r
 164                 BOOL IsRectNull() const                                         { return (left == 0 && right == 0 && top == 0 && bottom == 0); }\r
 165                 CRect MulDiv(int nMult, int nDiv) const         { return CRect ((left * nMult) / nDiv, (top * nMult) / nDiv,\r
 166                                                                                                                 (right * nMult) / nDiv, (bottom * nMult) / nDiv); }\r
 167                 void NormalizeRect()                                            { int nTemp; if (left > right) { nTemp = left; left = right; right = nTemp; }\r
 168                                                                                                                 if (top > bottom) { nTemp = top; top = bottom; bottom = nTemp; } }\r
 169                 BOOL OffsetRect(int dx, int dy)                         { return ::OffsetRect(this, dx, dy); }\r
 170                 BOOL OffsetRect(POINT pt)                                       { return ::OffsetRect(this, pt.x, pt.y); }\r
 171                 BOOL OffsetRect(SIZE size)                                      { return ::OffsetRect(this, size.cx, size.cy); }\r
 172                 BOOL PtInRect(POINT pt) const                           { return ::PtInRect(this, pt); }\r
 173                 BOOL SetRect(int l, int t, int r, int b)        { return ::SetRect(this, l, t, r, b); }\r
 174                 BOOL SetRect(POINT TopLeft, POINT BtmRight)     { return ::SetRect(this, TopLeft.x, TopLeft.y, BtmRight.x, BtmRight.y); }\r
 175                 BOOL SetRectEmpty()                                                     { return ::SetRectEmpty(this); }\r
 176                 BOOL SubtractRect(RECT rc1, RECT rc2)           { return ::SubtractRect(this, &rc1, &rc2); }\r
 177                 BOOL UnionRect(RECT rc1, RECT rc2)                      { return ::UnionRect(this, &rc1, &rc2); }\r
 178 \r
 179                 // Reposition rectangle\r
 180                 void MoveToX (int x)                                            { right = Width() + x; left = x; }\r
 181                 void MoveToY (int y)                                            { bottom = Height() + y; top = y; }\r
 182                 void MoveToXY (int x, int y)                            { MoveToX(x); MoveToY(y); }\r
 183                 void MoveToXY (POINT pt)                                        { MoveToX (pt.x); MoveToY (pt.y); }\r
 184 \r
 185                 // Attributes\r
 186                 int Height() const                                                      { return bottom - top; }\r
 187                 int Width() const                                                       { return right - left; }\r
 188                 CSize Size() const                                                      { return CSize(Width(), Height()); }\r
 189                 CPoint CenterPoint() const                                      { return CPoint((left + right) / 2, (top + bottom) / 2); }\r
 190                 CPoint TopLeft() const                                          { return CPoint(left, top); }\r
 191                 CPoint BottomRight() const                                      { return CPoint(right, bottom); }\r
 192 \r
 193                 // operators\r
 194                 operator LPRECT()                                                       { return this; }\r
 195                 BOOL operator == (RECT rc) const                        { return ::EqualRect(this, &rc); }\r
 196                 BOOL operator != (RECT rc) const                        { return !::EqualRect(this, &rc); }\r
 197                 void operator += (POINT pt)                                     { ::OffsetRect(this, pt.x, pt.y); }\r
 198                 void operator += (SIZE size)                            { ::OffsetRect(this, size.cx, size.cy); }\r
 199                 void operator += (RECT rc)                                      { ::InflateRect(this, rc.right - rc.left, rc.bottom - rc.top); }\r
 200                 void operator -= (RECT rc)                                      { ::InflateRect(this, rc.left - rc.right, rc.top - rc.bottom); }\r
 201                 void operator -= (POINT pt)                                     { ::OffsetRect(this, -pt.x, -pt.y); }\r
 202                 void operator -= (SIZE sz)                                      { ::OffsetRect(this, -sz.cx, -sz.cy); }\r
 203                 void operator &= (RECT rc)                                      { ::IntersectRect(this, this, &rc); }\r
 204                 void operator |= (RECT rc)                                      { ::UnionRect(this, this, &rc); }\r
 205 \r
 206                 // Operators returning CRect\r
 207                 CRect operator + (POINT pt) const                       { CRect rc(*this); ::OffsetRect(&rc, pt.x, pt.y); return rc; }\r
 208                 CRect operator - (POINT pt) const                       { CRect rc(*this); ::OffsetRect(&rc, -pt.x, -pt.y); return rc; }\r
 209                 CRect operator + (SIZE sz) const                        { CRect rc(*this); ::OffsetRect(&rc, sz.cx, sz.cy); return rc; }\r
 210                 CRect operator - (SIZE sz) const                        { CRect rc(*this); ::OffsetRect(&rc, -sz.cx, -sz.cy); return rc; }\r
 211                 CRect operator + (RECT rc) const                        { CRect rc1(*this); rc1.InflateRect(rc); return rc1; }\r
 212                 CRect operator - (RECT rc) const                        { CRect rc1(*this); rc1.DeflateRect(rc); return rc1; }\r
 213                 CRect operator & (RECT rc) const                        { CRect rc1; ::IntersectRect(&rc1, this, &rc); return rc1; }\r
 214                 CRect operator | (RECT rc) const                        { CRect rc1; ::UnionRect(&rc1, this, &rc); return rc1; }\r
 215         };\r
 216 \r
 217         // CSize member function definitions\r
 218         inline CPoint CSize::operator + (POINT pt) const        { return CPoint(pt) + *this; }\r
 219         inline CPoint CSize::operator - (POINT pt) const        { return CPoint(pt) - *this; }\r
 220         inline CRect CSize::operator + (RECT rc) const          { return CRect(rc) + *this; }\r
 221         inline CRect CSize::operator - (RECT rc) const          { return CRect(rc) - *this; }\r
 222 \r
 223         // CPoint member function definitions\r
 224         inline CRect CPoint::operator + (RECT rc) const         { return CRect(rc) + *this; }\r
 225         inline CRect CPoint::operator - (RECT rc) const         { return CRect(rc) - *this; }\r
 226 \r
 227 \r
 228         ////////////////////////////////////////////////////////\r
 229         // Classes and functions (typedefs) for text conversions\r
 230         //\r
 231         //  This section defines the following text conversions:\r
 232         //  A2BSTR              ANSI  to BSTR\r
 233         //  A2OLE               ANSI  to OLE\r
 234         //      A2T                     ANSI  to TCHAR\r
 235         //      A2W                     ANSI  to WCHAR\r
 236         //  OLE2A               OLE   to ANSI\r
 237         //  OLE2T               OLE   to TCHAR\r
 238         //  OLE2W               OLE   to WCHAR\r
 239         //  T2A                 TCHAR to ANSI\r
 240         //  T2BSTR              TCHAR to BSTR\r
 241         //  T2OLE       TCHAR to OLE\r
 242         //  T2W                 TCHAR to WCHAR\r
 243         //  W2A                 WCHAR to ANSI\r
 244         //  W2BSTR              WCHAR to BSTR\r
 245         //  W2OLE               WCHAR to OLE\r
 246         //  W2T                 WCHAR to TCHAR\r
 247 \r
 248         // About different character and string types:\r
 249         // ------------------------------------------\r
 250         // char (or CHAR) character types are ANSI (8 bits).\r
 251         // wchar_t (or WCHAR) character types are Unicode (16 bits).\r
 252         // TCHAR characters are Unicode if the _UNICODE macro is defined, otherwise they are ANSI.\r
 253         // BSTR (Basic String) is a type of string used in Visual Basic and COM programming.\r
 254         // OLE is the same as WCHAR. It is used in Visual Basic and COM programming.\r
 255 \r
 256 \r
 257         // Forward declarations of our classes. They are defined later.\r
 258         class CA2A;\r
 259         class CA2W;\r
 260         class CW2A;\r
 261         class CW2W;\r
 262         class CA2BSTR;\r
 263         class CW2BSTR;\r
 264 \r
 265         // typedefs for the well known text conversions\r
 266         typedef CA2W A2W;\r
 267         typedef CW2A W2A;\r
 268         typedef CW2BSTR W2BSTR;\r
 269         typedef CA2BSTR A2BSTR;\r
 270         typedef CW2A BSTR2A;\r
 271         typedef CW2W BSTR2W;\r
 272 \r
 273 #ifdef _UNICODE\r
 274         typedef CA2W A2T;\r
 275         typedef CW2A T2A;\r
 276         typedef CW2W T2W;\r
 277         typedef CW2W W2T;\r
 278         typedef CW2BSTR T2BSTR;\r
 279         typedef BSTR2W BSTR2T;\r
 280 #else\r
 281         typedef CA2A A2T;\r
 282         typedef CA2A T2A;\r
 283         typedef CA2W T2W;\r
 284         typedef CW2A W2T;\r
 285         typedef CA2BSTR T2BSTR;\r
 286         typedef BSTR2A BSTR2T;\r
 287 #endif\r
 288 \r
 289         typedef A2W  A2OLE;\r
 290         typedef T2W  T2OLE;\r
 291         typedef CW2W W2OLE;\r
 292         typedef W2A  OLE2A;\r
 293         typedef W2T  OLE2T;\r
 294         typedef CW2W OLE2W;\r
 295 \r
 296         class CA2W\r
 297         {\r
 298         public:\r
 299                 CA2W(LPCSTR pStr) : m_pStr(pStr)\r
 300                 {\r
 301                         if (pStr)\r
 302                         {\r
 303                                 // Resize the vector and assign null WCHAR to each element\r
 304                                 int length = (int)strlen(pStr)+1;\r
 305                                 m_vWideArray.assign(length, L'\0');\r
 306 \r
 307                                 // Fill our vector with the converted WCHAR array\r
 308                                 MultiByteToWideChar(CP_ACP, 0, pStr, -1, &m_vWideArray[0], length);\r
 309                         }\r
 310                 }\r
 311                 ~CA2W() {}\r
 312                 operator LPCWSTR() { return m_pStr? &m_vWideArray[0] : NULL; }\r
 313                 operator LPOLESTR() { return m_pStr? (LPOLESTR)&m_vWideArray[0] : (LPOLESTR)NULL; }\r
 314 \r
 315         private:\r
 316                 CA2W(const CA2W&);\r
 317                 CA2W& operator= (const CA2W&);\r
 318                 std::vector<wchar_t> m_vWideArray;\r
 319                 LPCSTR m_pStr;\r
 320         };\r
 321 \r
 322         class CW2A\r
 323         {\r
 324         public:\r
 325                 CW2A(LPCWSTR pWStr) : m_pWStr(pWStr)\r
 326                 {\r
 327                         // Resize the vector and assign null char to each element\r
 328                         int length = (int)wcslen(pWStr)+1;\r
 329                         m_vAnsiArray.assign(length, '\0');\r
 330 \r
 331                         // Fill our vector with the converted char array\r
 332                         WideCharToMultiByte(CP_ACP, 0, pWStr, -1, &m_vAnsiArray[0], length, NULL,NULL);\r
 333                 }\r
 334 \r
 335                 ~CW2A() {}\r
 336                 operator LPCSTR() { return m_pWStr? &m_vAnsiArray[0] : NULL; }\r
 337 \r
 338         private:\r
 339                 CW2A(const CW2A&);\r
 340                 CW2A& operator= (const CW2A&);\r
 341                 std::vector<char> m_vAnsiArray;\r
 342                 LPCWSTR m_pWStr;\r
 343         };\r
 344 \r
 345         class CW2W\r
 346         {\r
 347         public:\r
 348                 CW2W(LPCWSTR pWStr) : m_pWStr(pWStr) {}\r
 349                 operator LPCWSTR() { return (LPWSTR)m_pWStr; }\r
 350                 operator LPOLESTR() { return (LPOLESTR)m_pWStr; }\r
 351 \r
 352         private:\r
 353                 CW2W(const CW2W&);\r
 354                 CW2W& operator= (const CW2W&);\r
 355 \r
 356                 LPCWSTR m_pWStr;\r
 357         };\r
 358 \r
 359         class CA2A\r
 360         {\r
 361         public:\r
 362                 CA2A(LPCSTR pStr) : m_pStr(pStr) {}\r
 363                 operator LPCSTR() { return (LPSTR)m_pStr; }\r
 364 \r
 365         private:\r
 366                 CA2A(const CA2A&);\r
 367                 CA2A& operator= (const CA2A&);\r
 368 \r
 369                 LPCSTR m_pStr;\r
 370         };\r
 371 \r
 372         class CW2BSTR\r
 373         {\r
 374         public:\r
 375                 CW2BSTR(LPCWSTR pWStr) { m_bstrString = ::SysAllocString(pWStr); }\r
 376                 ~CW2BSTR() { ::SysFreeString(m_bstrString); }\r
 377                 operator BSTR() { return m_bstrString;}\r
 378 \r
 379         private:\r
 380                 CW2BSTR(const CW2BSTR&);\r
 381                 CW2BSTR& operator= (const CW2BSTR&);\r
 382                 BSTR m_bstrString;\r
 383         };\r
 384 \r
 385         class CA2BSTR\r
 386         {\r
 387         public:\r
 388                 CA2BSTR(LPCSTR pStr) { m_bstrString = ::SysAllocString(A2W(pStr)); }\r
 389                 ~CA2BSTR() { ::SysFreeString(m_bstrString); }\r
 390                 operator BSTR() { return m_bstrString;}\r
 391 \r
 392         private:\r
 393                 CA2BSTR(const CA2BSTR&);\r
 394                 CA2BSTR& operator= (const CA2BSTR&);\r
 395                 BSTR m_bstrString;\r
 396         };\r
 397 \r
 398 \r
 399         ////////////////////////////////////////\r
 400         // Global Functions\r
 401         //\r
 402 \r
 403         inline CWnd* FromHandle(HWND hWnd)\r
 404         // Returns the CWnd object associated with the window handle\r
 405         {\r
 406                 assert( GetApp() );\r
 407                 CWnd* pWnd = hWnd? GetApp()->GetCWndFromMap(hWnd) : 0;\r
 408                 if ( hWnd != NULL && pWnd == 0 )\r
 409                 {\r
 410                         GetApp()->AddTmpWnd(hWnd);\r
 411                         pWnd = GetApp()->GetCWndFromMap(hWnd);\r
 412                         ::PostMessage(hWnd, UWM_CLEANUPTEMPS, 0, 0);\r
 413                 }\r
 414 \r
 415                 return pWnd;\r
 416         }\r
 417 \r
 418         \r
 419         inline CWinApp* GetApp()\r
 420         // Returns a pointer to the CWinApp derrived class\r
 421         {\r
 422                 return CWinApp::SetnGetThis();\r
 423         }\r
 424 \r
 425         inline CPoint GetCursorPos()\r
 426         {\r
 427                 CPoint pt;\r
 428                 ::GetCursorPos(&pt);\r
 429                 return pt;\r
 430         }\r
 431 \r
 432         inline HBITMAP LoadBitmap (LPCTSTR lpszName)\r
 433         {\r
 434                 assert(GetApp());\r
 435 \r
 436                 HBITMAP hBitmap = (HBITMAP)::LoadImage (GetApp()->GetResourceHandle(), lpszName, IMAGE_BITMAP, 0, 0, LR_DEFAULTCOLOR);\r
 437                 return hBitmap;\r
 438         }\r
 439 \r
 440         inline HBITMAP LoadBitmap (int nID)\r
 441         {\r
 442                 return LoadBitmap(MAKEINTRESOURCE(nID));\r
 443         }\r
 444 \r
 445 \r
 446         inline void TRACE(LPCTSTR str)\r
 447         // TRACE sends a string to the debug/output pane, or an external debugger\r
 448         {\r
 449   #ifdef _DEBUG\r
 450                 OutputDebugString(str);\r
 451   #else\r
 452                 UNREFERENCED_PARAMETER(str); // no-op\r
 453   #endif\r
 454         }\r
 455 \r
 456   #ifndef _WIN32_WCE            // for Win32/64 operating systems, not WinCE\r
 457 \r
 458         inline int GetWinVersion()\r
 459         {\r
 460                 DWORD dwVersion = GetVersion();\r
 461                 int Platform = (dwVersion < 0x80000000)? 2:1;\r
 462                 int MajorVer = LOBYTE(LOWORD(dwVersion));\r
 463                 int MinorVer = HIBYTE(LOWORD(dwVersion));\r
 464 \r
 465                 int nVersion =  1000*Platform + 100*MajorVer + MinorVer;\r
 466 \r
 467                 // Return values and window versions:\r
 468                 //  1400     Windows 95\r
 469                 //  1410     Windows 98\r
 470                 //  1490     Windows ME\r
 471                 //  2400     Windows NT\r
 472                 //  2500     Windows 2000\r
 473                 //  2501     Windows XP\r
 474                 //  2502     Windows Server 2003\r
 475                 //  2600     Windows Vista and Windows Server 2008\r
 476                 //  2601     Windows 7\r
 477 \r
 478                 return nVersion;\r
 479         }\r
 480 \r
 481         inline int GetComCtlVersion()\r
 482         {\r
 483                 // Load the Common Controls DLL\r
 484                 HMODULE hComCtl = ::LoadLibraryA("COMCTL32.DLL");\r
 485                 if (!hComCtl)\r
 486                         return 0;\r
 487 \r
 488                 int ComCtlVer = 400;\r
 489 \r
 490                 if (::GetProcAddress(hComCtl, "InitCommonControlsEx"))\r
 491                 {\r
 492                         // InitCommonControlsEx is unique to 4.7 and later\r
 493                         ComCtlVer = 470;\r
 494 \r
 495                         if (::GetProcAddress(hComCtl, "DllGetVersion"))\r
 496                         {\r
 497                                 typedef HRESULT CALLBACK DLLGETVERSION(DLLVERSIONINFO*);\r
 498                                 DLLGETVERSION* pfnDLLGetVersion = NULL;\r
 499 \r
 500                                 pfnDLLGetVersion = (DLLGETVERSION*)::GetProcAddress(hComCtl, "DllGetVersion");\r
 501                                 if(pfnDLLGetVersion)\r
 502                                 {\r
 503                                         DLLVERSIONINFO dvi;\r
 504                                         dvi.cbSize = sizeof dvi;\r
 505                                         if(NOERROR == pfnDLLGetVersion(&dvi))\r
 506                                         {\r
 507                                                 DWORD dwVerMajor = dvi.dwMajorVersion;\r
 508                                                 DWORD dwVerMinor = dvi.dwMinorVersion;\r
 509                                                 ComCtlVer = 100 * dwVerMajor + dwVerMinor;\r
 510                                         }\r
 511                                 }\r
 512                         }\r
 513                         else if (::GetProcAddress(hComCtl, "InitializeFlatSB"))\r
 514                                 ComCtlVer = 471;        // InitializeFlatSB is unique to version 4.71\r
 515                 }\r
 516 \r
 517                 ::FreeLibrary(hComCtl);\r
 518 \r
 519                 // return values and DLL versions\r
 520                 // 400  dll ver 4.00    Windows 95/Windows NT 4.0\r
 521                 // 470  dll ver 4.70    Internet Explorer 3.x\r
 522                 // 471  dll ver 4.71    Internet Explorer 4.0\r
 523                 // 472  dll ver 4.72    Internet Explorer 4.01 and Windows 98\r
 524                 // 580  dll ver 5.80    Internet Explorer 5\r
 525                 // 581  dll ver 5.81    Windows 2000 and Windows ME\r
 526                 // 582  dll ver 5.82    Windows XP or Vista without XP themes\r
 527                 // 600  dll ver 6.00    Windows XP with XP themes\r
 528                 // 610  dll ver 6.10    Windows Vista with XP themes\r
 529                 // 616  dll ver 6.16    Windows Vista SP1 or Windows 7 with XP themes\r
 530 \r
 531                 return ComCtlVer;\r
 532         }\r
 533 \r
 534         inline UINT GetSizeofMenuItemInfo()\r
 535         {\r
 536                 UINT uSize = sizeof(MENUITEMINFO);\r
 537                 // For Win95 and NT, cbSize needs to be 44\r
 538                 if (1400 == (GetWinVersion()) || (2400 == GetWinVersion()))\r
 539                         uSize = 44;\r
 540 \r
 541                 return uSize;\r
 542         }\r
 543 \r
 544         inline UINT GetSizeofNonClientMetrics()\r
 545         {\r
 546                 // This function correctly determines the sizeof NONCLIENTMETRICS\r
 547                 UINT uSize = sizeof (NONCLIENTMETRICS);\r
 548 \r
 549   #if (WINVER >= 0x0600)\r
 550                 if (GetWinVersion() < 2600 && (uSize > 500))    // Is OS version less than Vista\r
 551                         uSize -= sizeof(int);           // Adjust size back to correct value\r
 552   #endif\r
 553 \r
 554                 return uSize;\r
 555         }\r
 556 \r
 557         \r
 558 \r
 559         // A global function to report the state of the left mouse button\r
 560         inline BOOL IsLeftButtonDown()\r
 561         {\r
 562                 SHORT state;\r
 563                 if (GetSystemMetrics(SM_SWAPBUTTON))\r
 564                         // Mouse buttons are swapped\r
 565                         state = GetAsyncKeyState(VK_RBUTTON);\r
 566                 else\r
 567                         // Mouse buttons are not swapped\r
 568                         state = GetAsyncKeyState(VK_LBUTTON);\r
 569 \r
 570                 // returns true if the left mouse button is down\r
 571                 return (state & 0x8000);\r
 572         }\r
 573 \r
 574         inline BOOL IsAeroThemed()\r
 575         {\r
 576                 BOOL bIsAeroThemed = FALSE;\r
 577 \r
 578                 // Test if Windows version is XP or greater\r
 579                 if (GetWinVersion() >= 2501)\r
 580                 {\r
 581                         HMODULE hMod = ::LoadLibrary(_T("uxtheme.dll"));\r
 582                         if(hMod)\r
 583                         {\r
 584                                 // Declare pointers to IsCompositionActive function\r
 585                                 FARPROC pIsCompositionActive = ::GetProcAddress(hMod, "IsCompositionActive");\r
 586 \r
 587                                 if(pIsCompositionActive)\r
 588                                 {\r
 589                                         if(pIsCompositionActive())\r
 590                                         {\r
 591                                                 bIsAeroThemed = TRUE;\r
 592                                         }\r
 593                                 }\r
 594                                 ::FreeLibrary(hMod);\r
 595                         }\r
 596                 }\r
 597 \r
 598                 return bIsAeroThemed;\r
 599         }\r
 600 \r
 601         inline BOOL IsXPThemed()\r
 602         {\r
 603                 BOOL bIsXPThemed = FALSE;\r
 604 \r
 605                 // Test if Windows version is XP or greater\r
 606                 if (GetWinVersion() >= 2501)\r
 607                 {\r
 608                         HMODULE hMod = ::LoadLibrary(_T("uxtheme.dll"));\r
 609                         if(hMod)\r
 610                         {\r
 611                                 // Declare pointers to functions\r
 612                                 FARPROC pIsAppThemed   = ::GetProcAddress(hMod, "IsAppThemed");\r
 613                                 FARPROC pIsThemeActive = ::GetProcAddress(hMod, "IsThemeActive");\r
 614 \r
 615                                 if(pIsAppThemed && pIsThemeActive)\r
 616                                 {\r
 617                                         if(pIsAppThemed() && pIsThemeActive())\r
 618                                         {\r
 619                                                 // Test if ComCtl32 dll used is version 6 or later\r
 620                                                 bIsXPThemed = (GetComCtlVersion() >= 600);\r
 621                                         }\r
 622                                 }\r
 623                                 ::FreeLibrary(hMod);\r
 624                         }\r
 625                 }\r
 626 \r
 627                 return bIsXPThemed;\r
 628         }\r
 629 \r
 630   #endif // #ifndef _WIN32_WCE\r
 631 \r
 632   // Required for WinCE\r
 633   #ifndef lstrcpyn\r
 634         inline LPTSTR lstrcpyn(LPTSTR lpstrDest, LPCTSTR lpstrSrc, int nLength)\r
 635         {\r
 636                 if(NULL == lpstrDest || NULL == lpstrSrc || nLength <= 0)\r
 637                         return NULL;\r
 638                 int nLen = MIN((int)lstrlen(lpstrSrc), nLength - 1);\r
 639                 LPTSTR lpstrRet = (LPTSTR)memcpy(lpstrDest, lpstrSrc, nLen * sizeof(TCHAR));\r
 640                 lpstrDest[nLen] = _T('\0');\r
 641                 return lpstrRet;\r
 642         }\r
 643   #endif // !lstrcpyn\r
 644 \r
 645 }\r
 646 \r
 647 \r
 648 #endif  // _WIN32XX_WINUTILS_H_\r