Debian Codegraph @

deps/winpty/src/agent/ConsoleFont.cc

raw
1 // Copyright (c) 2015 Ryan Prichard
2 //
3 // Permission is hereby granted, free of charge, to any person obtaining a copy
4 // of this software and associated documentation files (the "Software"), to
5 // deal in the Software without restriction, including without limitation the
6 // rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
7 // sell copies of the Software, and to permit persons to whom the Software is
8 // furnished to do so, subject to the following conditions:
9 //
10 // The above copyright notice and this permission notice shall be included in
11 // all copies or substantial portions of the Software.
12 //
13 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
14 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
15 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
16 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
17 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
18 // FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
19 // IN THE SOFTWARE.
20
21 #include "ConsoleFont.h"
22
23 #include <windows.h>
24 #include <stdio.h>
25 #include <string.h>
26 #include <wchar.h>
27
28 #include <algorithm>
29 #include <string>
30 #include <tuple>
31 #include <utility>
32 #include <vector>
33
34 #include "../shared/DebugClient.h"
35 #include "../shared/OsModule.h"
36 #include "../shared/StringUtil.h"
37 #include "../shared/WindowsVersion.h"
38 #include "../shared/WinptyAssert.h"
39 #include "../shared/winpty_snprintf.h"
40
41 namespace {
42
43 #define COUNT_OF(x) (sizeof(x) / sizeof((x)[0]))
44
45 // See https://en.wikipedia.org/wiki/List_of_CJK_fonts
46 const wchar_t kLucidaConsole[] = L"Lucida Console";
47 const wchar_t kMSGothic[] = { 0xff2d, 0xff33, 0x0020, 0x30b4, 0x30b7, 0x30c3, 0x30af, 0 }; // 932, Japanese
48 const wchar_t kNSimSun[] = { 0x65b0, 0x5b8b, 0x4f53, 0 }; // 936, Chinese Simplified
49 const wchar_t kGulimChe[] = { 0xad74, 0xb9bc, 0xccb4, 0 }; // 949, Korean
50 const wchar_t kMingLight[] = { 0x7d30, 0x660e, 0x9ad4, 0 }; // 950, Chinese Traditional
51
52 struct FontSize {
53 short size;
54 int width;
55 };
56
57 struct Font {
58 const wchar_t *faceName;
59 unsigned int family;
60 short size;
61 };
62
63 // Ideographs in East Asian languages take two columns rather than one.
64 // In the console screen buffer, a "full-width" character will occupy two
65 // cells of the buffer, the first with attribute 0x100 and the second with
66 // attribute 0x200.
67 //
68 // Windows does not correctly identify code points as double-width in all
69 // configurations. It depends heavily on the code page, the font facename,
70 // and (somehow) even the font size. In the 437 code page (MS-DOS), for
71 // example, no codepoints are interpreted as double-width. When the console
72 // is in an East Asian code page (932, 936, 949, or 950), then sometimes
73 // selecting a "Western" facename like "Lucida Console" or "Consolas" doesn't
74 // register, or if the font *can* be chosen, then the console doesn't handle
75 // double-width correctly. I tested the double-width handling by writing
76 // several code points with WriteConsole and checking whether one or two cells
77 // were filled.
78 //
79 // In the Japanese code page (932), Microsoft's default font is MS Gothic.
80 // MS Gothic double-width handling seems to be broken with console versions
81 // prior to Windows 10 (including Windows 10's legacy mode), and it's
82 // especially broken in Windows 8 and 8.1.
83 //
84 // Test by running: misc/Utf16Echo A2 A3 2014 3044 30FC 4000
85 //
86 // The first three codepoints are always rendered as half-width with the
87 // Windows Japanese fonts. (Of these, the first two must be half-width,
88 // but U+2014 could be either.) The last three are rendered as full-width,
89 // and they are East_Asian_Width=Wide.
90 //
91 // Windows 7 fails by modeling all codepoints as full-width with font
92 // sizes 22 and above.
93 //
94 // Windows 8 gets U+00A2, U+00A3, U+2014, U+30FC, and U+4000 wrong, but
95 // using a point size not listed in the console properties dialog
96 // (e.g. "9") is less wrong:
97 //
98 // | code point |
99 // font | 00A2 00A3 2014 3044 30FC 4000 | cell size
100 // ------------+---------------------------------+----------
101 // 8 | F F F F H H | 4x8
102 // 9 | F F F F F F | 5x9
103 // 16 | F F F F H H | 8x16
104 // raster 6x13 | H H H F F H(*) | 6x13
105 //
106 // (*) The Raster Font renders U+4000 as a white box (i.e. an unsupported
107 // character).
108 //
109
110 // See:
111 // - misc/Font-Report-June2016 directory for per-size details
112 // - misc/font-notes.txt
113 // - misc/Utf16Echo.cc, misc/FontSurvey.cc, misc/SetFont.cc, misc/GetFont.cc
114
115 const FontSize kLucidaFontSizes[] = {
116 { 5, 3 },
117 { 6, 4 },
118 { 8, 5 },
119 { 10, 6 },
120 { 12, 7 },
121 { 14, 8 },
122 { 16, 10 },
123 { 18, 11 },
124 { 20, 12 },
125 { 36, 22 },
126 { 48, 29 },
127 { 60, 36 },
128 { 72, 43 },
129 };
130
131 // Japanese. Used on Vista and Windows 7.
132 const FontSize k932GothicVista[] = {
133 { 6, 3 },
134 { 8, 4 },
135 { 10, 5 },
136 { 12, 6 },
137 { 13, 7 },
138 { 15, 8 },
139 { 17, 9 },
140 { 19, 10 },
141 { 21, 11 },
142 // All larger fonts are more broken w.r.t. full-size East Asian characters.
143 };
144
145 // Japanese. Used on Windows 8, 8.1, and the legacy 10 console.
146 const FontSize k932GothicWin8[] = {
147 // All of these characters are broken w.r.t. full-size East Asian
148 // characters, but they're equally broken.
149 { 5, 3 },
150 { 7, 4 },
151 { 9, 5 },
152 { 11, 6 },
153 { 13, 7 },
154 { 15, 8 },
155 { 17, 9 },
156 { 20, 10 },
157 { 22, 11 },
158 { 24, 12 },
159 // include extra-large fonts for small terminals
160 { 36, 18 },
161 { 48, 24 },
162 { 60, 30 },
163 { 72, 36 },
164 };
165
166 // Japanese. Used on the new Windows 10 console.
167 const FontSize k932GothicWin10[] = {
168 { 6, 3 },
169 { 8, 4 },
170 { 10, 5 },
171 { 12, 6 },
172 { 14, 7 },
173 { 16, 8 },
174 { 18, 9 },
175 { 20, 10 },
176 { 22, 11 },
177 { 24, 12 },
178 // include extra-large fonts for small terminals
179 { 36, 18 },
180 { 48, 24 },
181 { 60, 30 },
182 { 72, 36 },
183 };
184
185 // Chinese Simplified.
186 const FontSize k936SimSun[] = {
187 { 6, 3 },
188 { 8, 4 },
189 { 10, 5 },
190 { 12, 6 },
191 { 14, 7 },
192 { 16, 8 },
193 { 18, 9 },
194 { 20, 10 },
195 { 22, 11 },
196 { 24, 12 },
197 // include extra-large fonts for small terminals
198 { 36, 18 },
199 { 48, 24 },
200 { 60, 30 },
201 { 72, 36 },
202 };
203
204 // Korean.
205 const FontSize k949GulimChe[] = {
206 { 6, 3 },
207 { 8, 4 },
208 { 10, 5 },
209 { 12, 6 },
210 { 14, 7 },
211 { 16, 8 },
212 { 18, 9 },
213 { 20, 10 },
214 { 22, 11 },
215 { 24, 12 },
216 // include extra-large fonts for small terminals
217 { 36, 18 },
218 { 48, 24 },
219 { 60, 30 },
220 { 72, 36 },
221 };
222
223 // Chinese Traditional.
224 const FontSize k950MingLight[] = {
225 { 6, 3 },
226 { 8, 4 },
227 { 10, 5 },
228 { 12, 6 },
229 { 14, 7 },
230 { 16, 8 },
231 { 18, 9 },
232 { 20, 10 },
233 { 22, 11 },
234 { 24, 12 },
235 // include extra-large fonts for small terminals
236 { 36, 18 },
237 { 48, 24 },
238 { 60, 30 },
239 { 72, 36 },
240 };
241
242 // Some of these types and functions are missing from the MinGW headers.
243 // Others are undocumented.
244
245 struct AGENT_CONSOLE_FONT_INFO {
246 DWORD nFont;
247 COORD dwFontSize;
248 };
249
250 struct AGENT_CONSOLE_FONT_INFOEX {
251 ULONG cbSize;
252 DWORD nFont;
253 COORD dwFontSize;
254 UINT FontFamily;
255 UINT FontWeight;
256 WCHAR FaceName[LF_FACESIZE];
257 };
258
259 // undocumented XP API
260 typedef BOOL WINAPI SetConsoleFont_t(
261 HANDLE hOutput,
262 DWORD dwFontIndex);
263
264 // undocumented XP API
265 typedef DWORD WINAPI GetNumberOfConsoleFonts_t();
266
267 // XP and up
268 typedef BOOL WINAPI GetCurrentConsoleFont_t(
269 HANDLE hOutput,
270 BOOL bMaximumWindow,
271 AGENT_CONSOLE_FONT_INFO *lpConsoleCurrentFont);
272
273 // XP and up
274 typedef COORD WINAPI GetConsoleFontSize_t(
275 HANDLE hConsoleOutput,
276 DWORD nFont);
277
278 // Vista and up
279 typedef BOOL WINAPI GetCurrentConsoleFontEx_t(
280 HANDLE hConsoleOutput,
281 BOOL bMaximumWindow,
282 AGENT_CONSOLE_FONT_INFOEX *lpConsoleCurrentFontEx);
283
284 // Vista and up
285 typedef BOOL WINAPI SetCurrentConsoleFontEx_t(
286 HANDLE hConsoleOutput,
287 BOOL bMaximumWindow,
288 AGENT_CONSOLE_FONT_INFOEX *lpConsoleCurrentFontEx);
289
290 #define GET_MODULE_PROC(mod, funcName) \
291 m_##funcName = reinterpret_cast<funcName##_t*>((mod).proc(#funcName)); \
292
293 #define DEFINE_ACCESSOR(funcName) \
294 funcName##_t &funcName() const { \
295 ASSERT(valid()); \
296 return *m_##funcName; \
297 }
298
299 class XPFontAPI {
300 public:
301 XPFontAPI() : m_kernel32(L"kernel32.dll") {
302 GET_MODULE_PROC(m_kernel32, GetCurrentConsoleFont);
303 GET_MODULE_PROC(m_kernel32, GetConsoleFontSize);
304 }
305
306 bool valid() const {
307 return m_GetCurrentConsoleFont != NULL &&
308 m_GetConsoleFontSize != NULL;
309 }
310
311 DEFINE_ACCESSOR(GetCurrentConsoleFont)
312 DEFINE_ACCESSOR(GetConsoleFontSize)
313
314 private:
315 OsModule m_kernel32;
316 GetCurrentConsoleFont_t *m_GetCurrentConsoleFont;
317 GetConsoleFontSize_t *m_GetConsoleFontSize;
318 };
319
320 class VistaFontAPI : public XPFontAPI {
321 public:
322 VistaFontAPI() : m_kernel32(L"kernel32.dll") {
323 GET_MODULE_PROC(m_kernel32, GetCurrentConsoleFontEx);
324 GET_MODULE_PROC(m_kernel32, SetCurrentConsoleFontEx);
325 }
326
327 bool valid() const {
328 return this->XPFontAPI::valid() &&
329 m_GetCurrentConsoleFontEx != NULL &&
330 m_SetCurrentConsoleFontEx != NULL;
331 }
332
333 DEFINE_ACCESSOR(GetCurrentConsoleFontEx)
334 DEFINE_ACCESSOR(SetCurrentConsoleFontEx)
335
336 private:
337 OsModule m_kernel32;
338 GetCurrentConsoleFontEx_t *m_GetCurrentConsoleFontEx;
339 SetCurrentConsoleFontEx_t *m_SetCurrentConsoleFontEx;
340 };
341
342 static std::vector<std::pair<DWORD, COORD> > readFontTable(
343 XPFontAPI &api, HANDLE conout, DWORD maxCount) {
344 std::vector<std::pair<DWORD, COORD> > ret;
345 for (DWORD i = 0; i < maxCount; ++i) {
346 COORD size = api.GetConsoleFontSize()(conout, i);
347 if (size.X == 0 && size.Y == 0) {
348 break;
349 }
350 ret.push_back(std::make_pair(i, size));
351 }
352 return ret;
353 }
354
355 static void dumpFontTable(HANDLE conout, const char *prefix) {
356 const int kMaxCount = 1000;
357 if (!isTracingEnabled()) {
358 return;
359 }
360 XPFontAPI api;
361 if (!api.valid()) {
362 trace("dumpFontTable: cannot dump font table -- missing APIs");
363 return;
364 }
365 std::vector<std::pair<DWORD, COORD> > table =
366 readFontTable(api, conout, kMaxCount);
367 std::string line;
368 char tmp[128];
369 size_t first = 0;
370 while (first < table.size()) {
371 size_t last = std::min(table.size() - 1, first + 10 - 1);
372 winpty_snprintf(tmp, "%sfonts %02u-%02u:",
373 prefix, static_cast<unsigned>(first), static_cast<unsigned>(last));
374 line = tmp;
375 for (size_t i = first; i <= last; ++i) {
376 if (i % 10 == 5) {
377 line += " - ";
378 }
379 winpty_snprintf(tmp, " %2dx%-2d",
380 table[i].second.X, table[i].second.Y);
381 line += tmp;
382 }
383 trace("%s", line.c_str());
384 first = last + 1;
385 }
386 if (table.size() == kMaxCount) {
387 trace("%sfonts: ... stopped reading at %d fonts ...",
388 prefix, kMaxCount);
389 }
390 }
391
392 static std::string stringToCodePoints(const std::wstring &str) {
393 std::string ret = "(";
394 for (size_t i = 0; i < str.size(); ++i) {
395 char tmp[32];
396 winpty_snprintf(tmp, "%X", str[i]);
397 if (ret.size() > 1) {
398 ret.push_back(' ');
399 }
400 ret += tmp;
401 }
402 ret.push_back(')');
403 return ret;
404 }
405
406 static void dumpFontInfoEx(
407 const AGENT_CONSOLE_FONT_INFOEX &infoex,
408 const char *prefix) {
409 if (!isTracingEnabled()) {
410 return;
411 }
412 std::wstring faceName(infoex.FaceName,
413 winpty_wcsnlen(infoex.FaceName, COUNT_OF(infoex.FaceName)));
414 trace("%snFont=%u dwFontSize=(%d,%d) "
415 "FontFamily=0x%x FontWeight=%u FaceName=%s %s",
416 prefix,
417 static_cast<unsigned>(infoex.nFont),
418 infoex.dwFontSize.X, infoex.dwFontSize.Y,
419 infoex.FontFamily, infoex.FontWeight, utf8FromWide(faceName).c_str(),
420 stringToCodePoints(faceName).c_str());
421 }
422
423 static void dumpVistaFont(VistaFontAPI &api, HANDLE conout, const char *prefix) {
424 if (!isTracingEnabled()) {
425 return;
426 }
427 AGENT_CONSOLE_FONT_INFOEX infoex = {0};
428 infoex.cbSize = sizeof(infoex);
429 if (!api.GetCurrentConsoleFontEx()(conout, FALSE, &infoex)) {
430 trace("GetCurrentConsoleFontEx call failed");
431 return;
432 }
433 dumpFontInfoEx(infoex, prefix);
434 }
435
436 static void dumpXPFont(XPFontAPI &api, HANDLE conout, const char *prefix) {
437 if (!isTracingEnabled()) {
438 return;
439 }
440 AGENT_CONSOLE_FONT_INFO info = {0};
441 if (!api.GetCurrentConsoleFont()(conout, FALSE, &info)) {
442 trace("GetCurrentConsoleFont call failed");
443 return;
444 }
445 trace("%snFont=%u dwFontSize=(%d,%d)",
446 prefix,
447 static_cast<unsigned>(info.nFont),
448 info.dwFontSize.X, info.dwFontSize.Y);
449 }
450
451 static bool setFontVista(
452 VistaFontAPI &api,
453 HANDLE conout,
454 const Font &font) {
455 AGENT_CONSOLE_FONT_INFOEX infoex = {};
456 infoex.cbSize = sizeof(AGENT_CONSOLE_FONT_INFOEX);
457 infoex.dwFontSize.Y = font.size;
458 infoex.FontFamily = font.family;
459 infoex.FontWeight = 400;
460 winpty_wcsncpy_nul(infoex.FaceName, font.faceName);
461 dumpFontInfoEx(infoex, "setFontVista: setting font to: ");
462 if (!api.SetCurrentConsoleFontEx()(conout, FALSE, &infoex)) {
463 trace("setFontVista: SetCurrentConsoleFontEx call failed");
464 return false;
465 }
466 memset(&infoex, 0, sizeof(infoex));
467 infoex.cbSize = sizeof(infoex);
468 if (!api.GetCurrentConsoleFontEx()(conout, FALSE, &infoex)) {
469 trace("setFontVista: GetCurrentConsoleFontEx call failed");
470 return false;
471 }
472 if (wcsncmp(infoex.FaceName, font.faceName,
473 COUNT_OF(infoex.FaceName)) != 0) {
474 trace("setFontVista: face name was not set");
475 dumpFontInfoEx(infoex, "setFontVista: post-call font: ");
476 return false;
477 }
478 // We'd like to verify that the new font size is correct, but we can't
479 // predict what it will be, even though we just set it to `pxSize` through
480 // an apprently symmetric interface. For the Chinese and Korean fonts, the
481 // new `infoex.dwFontSize.Y` value can be slightly larger than the height
482 // we specified.
483 return true;
484 }
485
486 static Font selectSmallFont(int codePage, int columns, bool isNewW10) {
487 // Iterate over a set of font sizes according to the code page, and select
488 // one.
489
490 const wchar_t *faceName = nullptr;
491 unsigned int fontFamily = 0;
492 const FontSize *table = nullptr;
493 size_t tableSize = 0;
494
495 switch (codePage) {
496 case 932: // Japanese
497 faceName = kMSGothic;
498 fontFamily = 0x36;
499 if (isNewW10) {
500 table = k932GothicWin10;
501 tableSize = COUNT_OF(k932GothicWin10);
502 } else if (isAtLeastWindows8()) {
503 table = k932GothicWin8;
504 tableSize = COUNT_OF(k932GothicWin8);
505 } else {
506 table = k932GothicVista;
507 tableSize = COUNT_OF(k932GothicVista);
508 }
509 break;
510 case 936: // Chinese Simplified
511 faceName = kNSimSun;
512 fontFamily = 0x36;
513 table = k936SimSun;
514 tableSize = COUNT_OF(k936SimSun);
515 break;
516 case 949: // Korean
517 faceName = kGulimChe;
518 fontFamily = 0x36;
519 table = k949GulimChe;
520 tableSize = COUNT_OF(k949GulimChe);
521 break;
522 case 950: // Chinese Traditional
523 faceName = kMingLight;
524 fontFamily = 0x36;
525 table = k950MingLight;
526 tableSize = COUNT_OF(k950MingLight);
527 break;
528 default:
529 faceName = kLucidaConsole;
530 fontFamily = 0x36;
531 table = kLucidaFontSizes;
532 tableSize = COUNT_OF(kLucidaFontSizes);
533 break;
534 }
535
536 size_t bestIndex = static_cast<size_t>(-1);
537 std::tuple<int, int> bestScore = std::make_tuple(-1, -1);
538
539 // We might want to pick the smallest possible font, because we don't know
540 // how large the monitor is (and the monitor size can change). We might
541 // want to pick a larger font to accommodate console programs that resize
542 // the console on their own, like DOS edit.com, which tends to resize the
543 // console to 80 columns.
544
545 for (size_t i = 0; i < tableSize; ++i) {
546 const int width = table[i].width * columns;
547
548 // In general, we'd like to pick a font size where cutting the number
549 // of columns in half doesn't immediately violate the minimum width
550 // constraint. (e.g. To run DOS edit.com, a user might resize their
551 // terminal to ~100 columns so it's big enough to show the 80 columns
552 // post-resize.) To achieve this, give priority to fonts that allow
553 // this halving. We don't want to encourage *very* large fonts,
554 // though, so disable the effect as the number of columns scales from
555 // 80 to 40.
556 const int halfColumns = std::min(columns, std::max(40, columns / 2));
557 const int halfWidth = table[i].width * halfColumns;
558
559 std::tuple<int, int> thisScore = std::make_tuple(-1, -1);
560 if (width >= 160 && halfWidth >= 160) {
561 // Both sizes are good. Prefer the smaller fonts.
562 thisScore = std::make_tuple(2, -width);
563 } else if (width >= 160) {
564 // Prefer the smaller fonts.
565 thisScore = std::make_tuple(1, -width);
566 } else {
567 // Otherwise, prefer the largest font in our table.
568 thisScore = std::make_tuple(0, width);
569 }
570 if (thisScore > bestScore) {
571 bestIndex = i;
572 bestScore = thisScore;
573 }
574 }
575
576 ASSERT(bestIndex != static_cast<size_t>(-1));
577 return Font { faceName, fontFamily, table[bestIndex].size };
578 }
579
580 static void setSmallFontVista(VistaFontAPI &api, HANDLE conout,
581 int columns, bool isNewW10) {
582 int codePage = GetConsoleOutputCP();
583 const auto font = selectSmallFont(codePage, columns, isNewW10);
584 if (setFontVista(api, conout, font)) {
585 trace("setSmallFontVista: success");
586 return;
587 }
588 if (codePage == 932 || codePage == 936 ||
589 codePage == 949 || codePage == 950) {
590 trace("setSmallFontVista: falling back to default codepage font instead");
591 const auto fontFB = selectSmallFont(0, columns, isNewW10);
592 if (setFontVista(api, conout, fontFB)) {
593 trace("setSmallFontVista: fallback was successful");
594 return;
595 }
596 }
597 trace("setSmallFontVista: failure");
598 }
599
600 struct FontSizeComparator {
601 bool operator()(const std::pair<DWORD, COORD> &obj1,
602 const std::pair<DWORD, COORD> &obj2) const {
603 int score1 = obj1.second.X + obj1.second.Y;
604 int score2 = obj2.second.X + obj2.second.Y;
605 return score1 < score2;
606 }
607 };
608
609 } // anonymous namespace
610
611 // A Windows console window can never be larger than the desktop window. To
612 // maximize the possible size of the console in rows*cols, try to configure
613 // the console with a small font. Unfortunately, we cannot make the font *too*
614 // small, because there is also a minimum window size in pixels.
615 void setSmallFont(HANDLE conout, int columns, bool isNewW10) {
616 trace("setSmallFont: attempting to set a small font for %d columns "
617 "(CP=%u OutputCP=%u)",
618 columns,
619 static_cast<unsigned>(GetConsoleCP()),
620 static_cast<unsigned>(GetConsoleOutputCP()));
621 VistaFontAPI vista;
622 if (vista.valid()) {
623 dumpVistaFont(vista, conout, "previous font: ");
624 dumpFontTable(conout, "previous font table: ");
625 setSmallFontVista(vista, conout, columns, isNewW10);
626 dumpVistaFont(vista, conout, "new font: ");
627 dumpFontTable(conout, "new font table: ");
628 return;
629 }
630 trace("setSmallFont: neither Vista nor XP APIs detected -- giving up");
631 dumpFontTable(conout, "font table: ");
632 }