text: /*----------------------------------------------------------------------
    Copyright (c) 1998 Gipsysoft. All Rights Reserved.
    Please see the file "licence.txt" for licencing details.
    File:   WinHelper.h
    Owner:  russf@gipsysoft.com
    Purpose:        Windows helper functions, classes, structures and macros
    that make life a little easier
    These should all be zero impact classes etc. that is they 
    should *not* have a cpp file associated with them.
    ----------------------------------------------------------------------*/
  #ifndef WINHELPER_H
  #define WINHELPER_H
  
  //#ifndef DEBUGHLP_H
  //      #include <DebugHlp.h>
  //#endif        //      DEBUGHLP_H
  
  #ifndef FASTCALL
  #define FASTCALL
  #endif  //      FASTCALL
  
  extern void AssertFailed(char *, int, char *);
  extern void ApiFailure(char *, int, char *);
  
  #define R_VERIFY(a) R_ASSERT(a)
  #define R_ASSERT(a) \
    do {\
      if(!(a)) {\
        AssertFailed(__FILE__, __LINE__, #a);\
      }\
    } while(0);
  
  #define VAPI(a) \
    do { \
      if(!(a)) {\
       ApiFailure(__FILE__, __LINE__, #a); \
      }\
    } while (0);
  
  #define ASSERT_VALID_HWND(a) ASSERT( ::IsWindow(a) )
  
  namespace WinHelper
  {
  
    class CSize : public tagSIZE
      //
      //      Wrapper for the SIZE structure
      {
      public:
        inline CSize() {};
        inline explicit CSize( const SIZE &size ) { cx = size.cx; cy = size.cy; }
        inline explicit CSize( long nSizeX, long nSizeY ) { cx = nSizeX; cy = nSizeY; }
        inline void Set( long nSizeX, long nSizeY ) { cx = nSizeX; cy = nSizeY; }
        inline operator LPSIZE() { return this; };
  
        inline bool operator !=( const SIZE &size ) const { return cx != size.cx || cy != size.cy;}
        inline CSize & operator =( const SIZE &size ) { cx = size.cx; cy = size.cy; return *this; }
        inline void Empty() { cx = cy = 0; }
      };
  
  
    class CRect : public tagRECT
      //
      //      Wrapper for a RECT structure
      {
      public:
        inline CRect() {}
        //      Initialisation constructor
        inline explicit CRect( const RECT& rhs ) { Set( rhs.left, rhs.top, rhs.right, rhs.bottom );}
        inline CRect(int xLeft, int yTop, int xRight, int yBottom) { Set( xLeft, yTop, xRight, yBottom ); }
        //      Get the width of the rectangle
        inline int Width() const { return right - left; }
        //      Get the height of the rectangle
        inline int Height() const { return bottom - top; }
        //      overloaded operator so you don't have to do &rc anymore
        inline operator LPCRECT() const { return this; };
        inline operator LPRECT() { return this; };
        //      Return the SIZE of the rectangle;
        inline CSize Size() const { CSize s( Width(), Height() ); return s; }
        //      Return the top left of the rectangle
        inline POINT TopLeft() const { POINT pt = { left, top }; return pt; }   
        //      Return the bottom right of the rectangle
        inline POINT BottomRight() const { POINT pt = { right, bottom }; return pt; }   
        //      Set the rectangles left, top, right and bottom
        inline void Set( int xLeft, int yTop, int xRight, int yBottom) { top = yTop; bottom = yBottom; right = xRight; left = xLeft; }
        //      Return true if the rectangle contains all zeros
        inline bool IsEmpty() const { return left == 0 && right == 0 && top == 0 && bottom == 0 ? true : false; }
        //      Zero out our rectangle
        inline void Empty() { left = right = top = bottom = 0; }
        //      Set the size of the rect but leave the top left position untouched.
        inline void SetSize( const CSize &size ) { bottom = top + size.cy; right = left + size.cx; }
        inline void SetSize( const SIZE &size ) { bottom = top + size.cy; right = left + size.cx; }
        inline void SetSize( int cx, int cy ) { bottom = top + cy; right = left + cx; }
        //      Move the rectangle by an offset
        inline void Offset( int cx, int cy )
          {
            top+=cy;
            bottom+=cy;
            right+=cx;
            left+=cx;
          }
        //      Inflate the rectangle by the cx and cy, use negative to shrink the rectangle
        inline void Inflate( int cx, int cy )
          {
            top-=cy;
            bottom+=cy;
            right+=cx;
            left-=cx;
          }
        //      Assignment from a RECT
        inline CRect &operator = ( const RECT&rhs )
          {
            left = rhs.left; top = rhs.top;
            right = rhs.right; bottom = rhs.bottom;
            return *this;
          }
  
        //      Return true if the point passed is within the rectangle
        inline bool PtInRect( const POINT &pt ) const   {       return  ( pt.x >= left && pt.x < right && pt.y >=top && pt.y < bottom ); }
        //      Return true if the rectangle passed overlaps this rectangle
        inline bool Intersect( const RECT &rc ) const { return ( rc.left < right && rc.right > left && rc.top < bottom && rc.bottom > top ); }
      };
  
  
    class CPoint : public tagPOINT
      //
      //      Wrapper for the POINT structure
      {
      public:
        inline CPoint() {};
        inline CPoint( LPARAM lParam ) { x = LOWORD( lParam ); y = HIWORD(lParam); }
        inline CPoint( int nX, int nY ) { x = nX; y = nY; }
        inline CPoint( const POINT &pt ) { x = pt.x; y = pt.y; }
        inline bool operator == ( const CPoint &rhs ) const { return x == rhs.x && y == rhs.y; }
        inline bool operator != ( const CPoint &rhs ) const { return x != rhs.x || y != rhs.y; }
        inline operator LPPOINT () { return this; }
      };
  
  
    class CScrollInfo : public tagSCROLLINFO
      {
      public:
        CScrollInfo( UINT fPassedMask ) { cbSize = sizeof( tagSCROLLINFO ); fMask = fPassedMask; }
      };
  
  
    class CCriticalSection
      //
      //      Simple crtical section handler/wrapper
      {
      public:
        inline CCriticalSection()       { ::InitializeCriticalSection(&m_sect); }
        inline ~CCriticalSection() { ::DeleteCriticalSection(&m_sect); }
  
        //      Blocking lock.
        inline void Lock()                      { ::EnterCriticalSection(&m_sect); }
        //      Unlock
        inline void Unlock()            { ::LeaveCriticalSection(&m_sect); }
  
        class CLock
          //
          //      Simple lock class for the critcal section
          {
          public:
            inline CLock( CCriticalSection &sect ) : m_sect( sect ) { m_sect.Lock(); }
            inline ~CLock() { m_sect.Unlock(); }
          private:
            CCriticalSection &m_sect;
  
            CLock();
            CLock( const CLock &);
            CLock& operator =( const CLock &);
          };
  
      private:
        CRITICAL_SECTION m_sect;
  
        CCriticalSection( const CCriticalSection & );
        CCriticalSection& operator =( const CCriticalSection & );
      };
  
  
  #define ZeroStructure( t ) ZeroMemory( &t, sizeof( t ) )
  #define countof( t )    (sizeof( (t) ) / sizeof( (t)[0] ) )
  #define UNREF(P) UNREFERENCED_PARAMETER(P)
  
    inline bool IsShiftPressed()
      {
        return GetKeyState(VK_SHIFT) & 0x8000 ? true : false;
      }
  
    inline bool IsAltPressed()
      {
        return GetKeyState(VK_MENU) & 0x8000 ? true : false;
      }
  
    inline bool IsControlPressed()
      {
        return GetKeyState(VK_CONTROL) & 0x8000 ? true : false;
      }
  
    inline HICON LoadIcon16x16( HINSTANCE hInst, UINT uID )
      //
      //      Load a 16x16 icon from the same resource as the other size icons.
      {
        return reinterpret_cast<HICON>( ::LoadImage( hInst, MAKEINTRESOURCE( uID ), IMAGE_ICON, 16, 16, LR_DEFAULTCOLOR ) );
      }
  
  
    class CDeferWindowPos
      //
      //      Wrapper for the Begin, Defer and End WindowPos functions. Nothing glamorous.
      {
      public:
        inline CDeferWindowPos( const int nWindows = 1 ) : m_hdlDef( ::BeginDeferWindowPos( nWindows ) ) {}
        inline ~CDeferWindowPos() { R_VERIFY( ::EndDeferWindowPos( m_hdlDef ) ); }
        inline HDWP DeferWindowPos( HWND hWnd, HWND hWndInsertAfter , int x, int y, int cx, int cy, UINT uFlags )
          {
            return ::DeferWindowPos( m_hdlDef, hWnd, hWndInsertAfter, x, y, cx, cy, uFlags );
          }
        inline HDWP DeferWindowPos( HWND hWnd, HWND hWndInsertAfter, const CRect &rc, UINT uFlags )
          {
            return ::DeferWindowPos( m_hdlDef, hWnd, hWndInsertAfter, rc.left, rc.top, rc.Width(), rc.Height(), uFlags );
          }
  
      private:
        HDWP m_hdlDef;
      };
  
  }       //      WinHelper
  
  #endif //WINHELPER_H
  