matplotlib/src/_c_internal_utils.cpp at main · ActiveState/matplotlib · GitHub

Repository navigation

History

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

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

262

263

264

265

266

267

268

269

270

271

272

273

274

275

276

277

278

279

280

281

282

283

284

285

286

287

288

289

290

291

292

293

294

295

296

297

298

299

300

301

302

303

304

305

306

307

308

309

310

311

312

313

#include <Python.h>

/* Python.h must be included before any system headers,

to ensure visibility macros are properly set. */

#include <stdexcept>

#ifdef _WIN32

#define WIN32_LEAN_AND_MEAN

// Windows 10, for latest HiDPI API support.

#define WINVER 0x0A00

#if defined(_WIN32_WINNT)

#if _WIN32_WINNT < WINVER

#undef _WIN32_WINNT

#define _WIN32_WINNT WINVER

#endif

#else

#define _WIN32_WINNT WINVER

#endif

#include <pybind11/pybind11.h>

#ifdef __linux__

#include <dlfcn.h>

#endif

#ifdef _WIN32

#include <Objbase.h>

#include <Shobjidl.h>

#include <Windows.h>

#define UNUSED_ON_NON_WINDOWS(x) x

#else

#define UNUSED_ON_NON_WINDOWS Py_UNUSED

#endif

#ifdef __APPLE__

#include <CoreFoundation/CoreFoundation.h>

#include <CoreText/CoreText.h>

#endif

namespace py = pybind11;

using namespace pybind11::literals;

static bool

mpl_xdisplay_is_valid(void)

{

#ifdef __linux__

void* libX11;

// The getenv check is redundant but helps performance as it is much faster

// than dlopen().

if (getenv("DISPLAY")

&& (libX11 = dlopen("libX11.so.6", RTLD_LAZY))) {

struct Display* display = nullptr;

auto XOpenDisplay = (struct Display* (*)(char const*))

dlsym(libX11, "XOpenDisplay");

auto XCloseDisplay = (int (*)(struct Display*))

dlsym(libX11, "XCloseDisplay");

if (XOpenDisplay && XCloseDisplay

&& (display = XOpenDisplay(nullptr))) {

XCloseDisplay(display);

}

if (dlclose(libX11)) {

throw std::runtime_error(dlerror());

}

if (display) {

return true;

}

return false;

#else

return true;

#endif

}

static bool

mpl_display_is_valid(void)

{

#ifdef __linux__

if (mpl_xdisplay_is_valid()) {

return true;

}

void* libwayland_client;

if (getenv("WAYLAND_DISPLAY")

&& (libwayland_client = dlopen("libwayland-client.so.0", RTLD_LAZY))) {

struct wl_display* display = nullptr;

auto wl_display_connect = (struct wl_display* (*)(char const*))

dlsym(libwayland_client, "wl_display_connect");

auto wl_display_disconnect = (void (*)(struct wl_display*))

dlsym(libwayland_client, "wl_display_disconnect");

if (wl_display_connect && wl_display_disconnect

&& (display = wl_display_connect(nullptr))) {

wl_display_disconnect(display);

}

if (dlclose(libwayland_client)) {

throw std::runtime_error(dlerror());

}

if (display) {

return true;

}

return false;

#else

return true;

#endif

}

static py::object

mpl_get_available_fonts(void)

{

#if defined(__APPLE__)

py::set fonts;

auto cfStringToPyStr = [](CFStringRef str) -> py::str {

auto cstr = CFStringGetCStringPtr(str, kCFStringEncodingUTF8);

if (cstr) {

return py::str(cstr);

}

auto length = CFStringGetLength(str);

auto maxSize = CFStringGetMaximumSizeForEncoding(length, kCFStringEncodingUTF8) + 1;

auto buffer = std::make_unique<char[]>(maxSize);

py::str result;

if (CFStringGetCString(str, buffer.get(), maxSize, kCFStringEncodingUTF8)) {

result = py::str(buffer.get());

}

return result;

};

auto collection = CTFontCollectionCreateFromAvailableFonts(NULL);

auto descriptors = collection ?

CTFontCollectionCreateMatchingFontDescriptors(collection) : NULL;

auto count = descriptors ? CFArrayGetCount(descriptors) : 0;

for (CFIndex i = 0; i < count; i++) {

auto descriptor = static_cast<CTFontDescriptorRef>(

CFArrayGetValueAtIndex(descriptors, i));

auto url = static_cast<CFURLRef>(

CTFontDescriptorCopyAttribute(descriptor, kCTFontURLAttribute));

CFStringRef path = nullptr;

if (url) {

path = CFURLCopyFileSystemPath(url, kCFURLPOSIXPathStyle);

CFRelease(url);

}

if (path) {

auto pyStr = cfStringToPyStr(path);

if (pyStr) {

fonts.add(pyStr);

}

CFRelease(path);

}

if (descriptors) {

CFRelease(descriptors);

}

if (collection) {

CFRelease(collection);

}

return fonts;

#else

return py::none();

#endif

}

static py::object

mpl_GetCurrentProcessExplicitAppUserModelID(void)

{

#ifdef _WIN32

wchar_t* appid = NULL;

HRESULT hr = GetCurrentProcessExplicitAppUserModelID(&appid);

if (FAILED(hr)) {

PyErr_SetFromWindowsErr(hr);

throw py::error_already_set();

}

auto py_appid = py::cast(appid);

CoTaskMemFree(appid);

return py_appid;

#else

return py::none();

#endif

}

static void

mpl_SetCurrentProcessExplicitAppUserModelID(const wchar_t* UNUSED_ON_NON_WINDOWS(appid))

{

#ifdef _WIN32

HRESULT hr = SetCurrentProcessExplicitAppUserModelID(appid);

if (FAILED(hr)) {

PyErr_SetFromWindowsErr(hr);

throw py::error_already_set();

}

#endif

}

static py::object

mpl_GetForegroundWindow(void)

{

#ifdef _WIN32

if (HWND hwnd = GetForegroundWindow()) {

return py::capsule(hwnd, "HWND");

} else {

return py::none();

}

#else

return py::none();

#endif

}

static void

mpl_SetForegroundWindow(py::capsule UNUSED_ON_NON_WINDOWS(handle_p))

{

#ifdef _WIN32

if (strcmp(handle_p.name(), "HWND") != 0) {

throw std::runtime_error("Handle must be a value returned from Win32_GetForegroundWindow");

}

HWND handle = static_cast<HWND>(handle_p.get_pointer());

if (!SetForegroundWindow(handle)) {

throw std::runtime_error("Error setting window");

}

#endif

}

static void

mpl_SetProcessDpiAwareness_max(void)

{

#ifdef _WIN32

#ifdef _DPI_AWARENESS_CONTEXTS_

// These functions and options were added in later Windows 10 updates, so

// must be loaded dynamically.

HMODULE user32 = LoadLibrary("user32.dll");

auto IsValidDpiAwarenessContext = (BOOL (WINAPI *)(DPI_AWARENESS_CONTEXT))

GetProcAddress(user32, "IsValidDpiAwarenessContext");

auto SetProcessDpiAwarenessContext = (BOOL (WINAPI *)(DPI_AWARENESS_CONTEXT))

GetProcAddress(user32, "SetProcessDpiAwarenessContext");

DPI_AWARENESS_CONTEXT ctxs[3] = {

DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE_V2, // Win10 Creators Update

DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE, // Win10

DPI_AWARENESS_CONTEXT_SYSTEM_AWARE}; // Win10

if (IsValidDpiAwarenessContext && SetProcessDpiAwarenessContext) {

for (size_t i = 0; i < sizeof(ctxs) / sizeof(DPI_AWARENESS_CONTEXT); ++i) {

if (IsValidDpiAwarenessContext(ctxs[i])) {

SetProcessDpiAwarenessContext(ctxs[i]);

break;

}

} else {

// Added in Windows Vista.

SetProcessDPIAware();

}

FreeLibrary(user32);

#else

// Added in Windows Vista.

SetProcessDPIAware();

#endif

}

PYBIND11_MODULE(_c_internal_utils, m, py::mod_gil_not_used())

{

m.def(

"display_is_valid", &mpl_display_is_valid,

R"""( --

Check whether the current X11 or Wayland display is valid.

On Linux, returns True if either $DISPLAY is set and XOpenDisplay(NULL)

succeeds, or $WAYLAND_DISPLAY is set and wl_display_connect(NULL)

succeeds.

On other platforms, always returns True.)""");

m.def(

"xdisplay_is_valid", &mpl_xdisplay_is_valid,

R"""( --

Check whether the current X11 display is valid.

On Linux, returns True if either $DISPLAY is set and XOpenDisplay(NULL)

succeeds. Use this function if you need to specifically check for X11

only (e.g., for Tkinter).

On other platforms, always returns True.)""");

m.def(

"get_available_fonts", &mpl_get_available_fonts,

R"""( --

On macOS, uses CoreText to find all fonts available to the current

process and returns the paths as a set of strings.

On other platforms, always returns None.)""");

m.def(

"Win32_GetCurrentProcessExplicitAppUserModelID",

&mpl_GetCurrentProcessExplicitAppUserModelID,

R"""( --

Wrapper for Windows's GetCurrentProcessExplicitAppUserModelID.

On non-Windows platforms, always returns None.)""");

m.def(

"Win32_SetCurrentProcessExplicitAppUserModelID",

&mpl_SetCurrentProcessExplicitAppUserModelID,

"appid"_a, py::pos_only(),

R"""( --

Wrapper for Windows's SetCurrentProcessExplicitAppUserModelID.

On non-Windows platforms, does nothing.)""");

m.def(

"Win32_GetForegroundWindow", &mpl_GetForegroundWindow,

R"""( --

Wrapper for Windows' GetForegroundWindow.

On non-Windows platforms, always returns None.)""");

m.def(

"Win32_SetForegroundWindow", &mpl_SetForegroundWindow,

"hwnd"_a,

R"""( --

Wrapper for Windows' SetForegroundWindow.

On non-Windows platforms, does nothing.)""");

m.def(

"Win32_SetProcessDpiAwareness_max", &mpl_SetProcessDpiAwareness_max,

R"""( --

Set Windows' process DPI awareness to best option available.

On non-Windows platforms, does nothing.)""");

}

matplotlib/src/_c_internal_utils.cpp at main · ActiveState/matplotlib · GitHub

Repository navigation

Expand file tree

Breadcrumbs

_c_internal_utils.cpp

Latest commit

History

Breadcrumbs

_c_internal_utils.cpp

File metadata and controls