WinTypes.h

Go to the documentation of this file.

//
//
 
#ifndef _INC_WinTypes_H
#define _INC_WinTypes_H
#ifndef NO_PRAGMA_ONCE
#pragma once
#endif
 
#include "../GrayLibBase.h"
#include "GrayCore/include/StrConst.h"
#include "GrayCore/include/StrT.h"
#include "GrayCore/include/cMem.h"
#include "GrayCore/include/cOSProcess.h"        // WINHANDLE_NULL
 
#ifdef __linux__
 
// Linux doesn't define this stuff. just dummy this for prototypes.
typedef void* HWND;     // dummy this
typedef void* HDC;
typedef void* HBITMAP;
typedef void* HRGN;
typedef void* HCURSOR;
 
typedef INT_PTR LRESULT;
typedef LONG LPARAM;
typedef LONG WPARAM;
typedef const char* ATOM; // WORD in _WIN32
typedef char CHAR;
 
enum WINMSG_t
{
#define WINMSGDEF(a,b,c) WM_##a = b,
#include "WinMsgs.tbl"
#undef WINMSGDEF
};
 
// Define the basic Windows style geometric structs.
 
typedef struct tagSIZE
{
        LONG  cx;
        LONG  cy;
} SIZE;
 
typedef struct tagPOINT
{
        LONG  x;
        LONG  y;
} POINT;
 
typedef struct tagPOINTS
{
        short   x;
        short   y;
} POINTS;
 
typedef struct tagRECT
{
        LONG    left;   
        LONG    top;    
        LONG    right;  
        LONG    bottom; 
} RECT;
 
typedef struct tagMSG
{
        HWND        hwnd;
        UINT        message;
        WPARAM      wParam;
        LPARAM      lParam;
        DWORD       time;
        POINT       pt;
#ifdef _MAC
        DWORD       lPrivate;
#endif
} MSG;
 
#define LF_FACESIZE         32
typedef struct tagLOGFONTA
{
        LONG      lfHeight;
        LONG      lfWidth;
        LONG      lfEscapement;
        LONG      lfOrientation;
        LONG      lfWeight;
        BYTE      lfItalic;
        BYTE      lfUnderline;
        BYTE      lfStrikeOut;
        BYTE      lfCharSet;
        BYTE      lfOutPrecision;
        BYTE      lfClipPrecision;
        BYTE      lfQuality;
        BYTE      lfPitchAndFamily;
        CHAR      lfFaceName[LF_FACESIZE];
} LOGFONTA;
// typedef LOGFONTA LOGFONT;
 
struct WINDOWPLACEMENT
{
};
 
#else // _WIN32
 
 
typedef UINT WINMSG_t;          
 
#ifndef WM_NULL
#define WM_NULL 0               // WINMSG_t
#endif
#ifndef WM_MOUSEWHEEL
#define WM_MOUSEWHEEL   0x020A  
#endif
 
#endif  // _WIN32
 
#define MF_GREYED 1     
 
namespace GrayLib
{
        class cWinSize : public SIZE
        {
 
        public:
                cWinSize(LONG _cx = 0, LONG _cy = 0) noexcept
                {
                        this->cx = _cx;
                        this->cy = _cy;
                }
                cWinSize(const SIZE& rsize) noexcept
                {
                        *static_cast<SIZE*>(this) = rsize;
                }
                bool operator == (const SIZE& rsize) const noexcept
                {
                        return(rsize.cx == this->cx && rsize.cy == this->cy);
                }
                bool PtInRect(int x, int y) const noexcept
                {
                        if (x < 0 || x >= this->cx)
                                return false;
                        if (y < 0 || y >= this->cy)
                                return false;
                        return true;
                }
                bool isZero() const noexcept
                {
                        return(cx == 0 && cy == 0);
                }
                void SetZero() noexcept
                {
                        cx = 0; cy = 0;
                }
                float get_AspectRatio() const noexcept;
                void SetMaxAspect(int maxx, int maxy);
        };
 
        class cWinFontCfg : public _GTN(LOGFONT)
        {
 
                typedef _GTN(LOGFONT) SUPER_t;
 
        public:
                cWinFontCfg() noexcept
                {
                        InitZero();
                }
                cWinFontCfg(const SUPER_t& fontcfg) noexcept
                {
                        ref_LogFont() = fontcfg;
                }
                SUPER_t& ref_LogFont() noexcept
                {
                        return *static_cast<SUPER_t*>(this);
                }
                const SUPER_t& ref_LogFont() const noexcept
                {
                        return *static_cast<const SUPER_t*>(this);
                }
                void InitZero() noexcept
                {
                        cMem::Zero(static_cast<SUPER_t*>(this), sizeof(SUPER_t));
                }
                StrLen_t put_FaceName(const GChar_t* pszFaceName) noexcept
                {
                        // ASSUME LF_FACESIZE MAX
                        return StrT::CopyLen<GChar_t>(this->lfFaceName, pszFaceName, _countof(this->lfFaceName));
                }
                bool IsSameFont(const SUPER_t& rFont) const noexcept
                {
                        return !::memcmp(static_cast<const SUPER_t*>(this), &rFont, sizeof(SUPER_t));
                }
                int get_FontSize() const noexcept
                {
                        return this->lfHeight;
                }
                int get_FontSizeA() const noexcept
                {
                        if (this->lfHeight == 0)        // use default.
                        {
                                return 10;
                        }
                        return ABS(this->lfHeight);
                }
                int get_FontWidthA() const noexcept
                {
                        if (this->lfWidth == 0) // use default.
                        {
                                return 10;
                        }
                        return ABS(this->lfWidth);
                }
        };
 
        class cWindowPlacement : public ::WINDOWPLACEMENT
        {
 
                typedef ::WINDOWPLACEMENT SUPER_t;
 
        public:
                cWindowPlacement() noexcept
                {
                        cMem::Zero(static_cast<SUPER_t*>(this), sizeof(SUPER_t));
                        // this->length = 0;
                        this->ptMinPosition.x = -1;     // pick some random position.
                        this->ptMinPosition.y = -1;
                        this->ptMaxPosition.x = -1;
                        this->ptMaxPosition.y = -1;
                }
 
#ifdef _WIN32
                cWindowPlacement(HWND hWnd)
                {
                        UpdatePlacement(hWnd);
                }
                bool UpdatePlacement(HWND hWnd)
                {
                        return ::GetWindowPlacement(hWnd, static_cast<SUPER_t*>(this));
                }
#endif
 
                void InitPlacement() noexcept
                {
                        // Make this valid and empty.
                        this->length = sizeof(SUPER_t);
                }
                bool isInitPlacement() const noexcept
                {
                        return this->length == sizeof(SUPER_t);
                }
                SHOWWINDOW_t get_ShowWindowwMode() const noexcept
                {
                        return (SHOWWINDOW_t)(this->showCmd);
                }
                bool isShowIconic() const noexcept
                {
                        return (get_ShowWindowwMode() == SW_SHOWMINIMIZED || get_ShowWindowwMode() == SW_SHOWMINNOACTIVE);
                }
 
                const RECT& get_NormalRect() const noexcept
                {
                        return this->rcNormalPosition;
                }
        };
 
#if defined(_DEBUG) && defined(_WIN32)
        GRAYLIB_LINK StrLen_t GRAYCALL MakeWinMsgStr(char* pszOut, StrLen_t nCharsMax, WINMSG_t uMsg, WPARAM wParam, LPARAM lParam);
#endif
}
 
#endif // WinTypes