1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
|
#ifndef COMMON_H
#define COMMON_H
#include <memory>
#include <optional>
#include <windows.h>
#ifdef UNICODE
#define WA "W"
#else
#define WA "A"
#endif
struct wstring_owner
{
wstring_owner();
wstring_owner(wchar_t* wsz);
wstring_owner& operator=(wchar_t* wsz);
wstring_owner(wstring_owner& wso) = delete;
wstring_owner& operator=(wstring_owner& wso) = delete;
wstring_owner(wstring_owner&& wso) noexcept;
wstring_owner& operator=(wstring_owner&& wso) noexcept;
wchar_t *release();
operator bool() const;
~wstring_owner();
wchar_t* p = nullptr;
};
wstring_owner WsoFromSz(const char* sz, int iCp = CP_UTF8);
int EBMessageBox(const wchar_t* wszText, const wchar_t* wszCaption, unsigned uType);
struct Win32Error : public std::exception
{
Win32Error();
Win32Error(DWORD dwErr);
~Win32Error();
const char* what() const noexcept;
const wchar_t* WhatW() const noexcept;
DWORD dwErr;
private:
char* m_szMsg = NULL;
wchar_t* m_wszMsg = NULL;
};
struct Library
{
Library(const wchar_t* wszLibrary);
~Library();
template <class T> T* GetProcAddress(const char* szProc);
private:
HMODULE m_hModule;
};
template <typename T>
T* Library::GetProcAddress(const char* const szProc)
{
return (T*)(void*)::GetProcAddress(m_hModule, szProc);
}
template<size_t N, typename... T>
inline auto wszf(wchar_t (&wsz)[N], const wchar_t* wszFmt, T... xs)
{
return swprintf_s(wsz, N, wszFmt, xs...);
}
/* Create and return an object of type C. If construction fails,
* return nothing. The returned value must be checked before being
* used, as dereferencing is undefined if the value is empty. */
template <typename T, typename... U>
std::optional<T> maybe_make(U... xs)
{
try {
return T(xs...);
} catch (...) {
return {};
}
}
/* Variable template for caching values from GetSystemMetrics. */
template <int I>
auto Metric = GetSystemMetrics(I);
/* Check result of Windows API call, throwing error on NULL. */
template <typename T>
inline T require(const T x)
{
if (!x) throw Win32Error();
return x;
}
/* Check result of Windows API call, showing a warning on NULL. */
template <typename T>
inline T prefer(const T x)
{
if (!x) {
EBMessageBox(Win32Error().WhatW(), L"System Error", MB_ICONWARNING);
return (T)NULL;
}
return x;
}
/* Return integer scaled for current DPI. */
inline int Dpi(const int i)
{
extern int g_iDPI;
return MulDiv(i, g_iDPI, 96);
}
inline int Cmp(const int a, const int b)
{
if (a == b) return 0;
if (a > b) return 1;
return -1;
}
/* Get window rectangle relative to parent. */
inline BOOL GetRelativeRect(const HWND hWnd, RECT* const pRr)
{
if (!GetClientRect(hWnd, pRr)) return 0;
return MapWindowPoints(hWnd, GetParent(hWnd), (POINT*)pRr, 2);
}
inline BOOL SetWindowRect(const HWND hWnd,
const long left, const long top, const long right, const long bottom)
{
return MoveWindow(hWnd,
left, top,
right-left, bottom-top,
TRUE);
}
inline BOOL SetWindowRect(const HWND hWnd, const RECT r)
{
return SetWindowRect(hWnd, r.left, r.top, r.right, r.bottom);
}
#endif
|