projects / u / mdw / putty / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Extensive changes that _should_ fix the socket buffering problems,
[u/mdw/putty] / window.c
1 #include <windows.h>
2 #include <imm.h>
3 #include <commctrl.h>
4 #include <mmsystem.h>
5 #ifndef AUTO_WINSOCK
6 #ifdef WINSOCK_TWO
7 #include <winsock2.h>
8 #else
9 #include <winsock.h>
10 #endif
11 #endif
12 #include <stdio.h>
13 #include <stdlib.h>
14 #include <ctype.h>
15 #include <time.h>
16
17 #define PUTTY_DO_GLOBALS /* actually _define_ globals */
18 #include "putty.h"
19 #include "winstuff.h"
20 #include "storage.h"
21 #include "win_res.h"
22
23 #define IDM_SHOWLOG 0x0010
24 #define IDM_NEWSESS 0x0020
25 #define IDM_DUPSESS 0x0030
26 #define IDM_RECONF 0x0040
27 #define IDM_CLRSB 0x0050
28 #define IDM_RESET 0x0060
29 #define IDM_TEL_AYT 0x0070
30 #define IDM_TEL_BRK 0x0080
31 #define IDM_TEL_SYNCH 0x0090
32 #define IDM_TEL_EC 0x00a0
33 #define IDM_TEL_EL 0x00b0
34 #define IDM_TEL_GA 0x00c0
35 #define IDM_TEL_NOP 0x00d0
36 #define IDM_TEL_ABORT 0x00e0
37 #define IDM_TEL_AO 0x00f0
38 #define IDM_TEL_IP 0x0100
39 #define IDM_TEL_SUSP 0x0110
40 #define IDM_TEL_EOR 0x0120
41 #define IDM_TEL_EOF 0x0130
42 #define IDM_ABOUT 0x0140
43 #define IDM_SAVEDSESS 0x0150
44 #define IDM_COPYALL 0x0160
45
46 #define IDM_SESSLGP 0x0250 /* log type printable */
47 #define IDM_SESSLGA 0x0260 /* log type all chars */
48 #define IDM_SESSLGE 0x0270 /* log end */
49 #define IDM_SAVED_MIN 0x1000
50 #define IDM_SAVED_MAX 0x2000
51
52 #define WM_IGNORE_SIZE (WM_XUSER + 1)
53 #define WM_IGNORE_CLIP (WM_XUSER + 2)
54
55 /* Needed for Chinese support and apparently not always defined. */
56 #ifndef VK_PROCESSKEY
57 #define VK_PROCESSKEY 0xE5
58 #endif
59
60 /* Needed for mouse wheel support and not defined in earlier SDKs. */
61 #ifndef WM_MOUSEWHEEL
62 #define WM_MOUSEWHEEL 0x020A
63 #endif
64
65 static LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM);
66 static int TranslateKey(UINT message, WPARAM wParam, LPARAM lParam,
67 unsigned char *output);
68 static void cfgtopalette(void);
69 static void init_palette(void);
70 static void init_fonts(int);
71 static void another_font(int);
72 static void deinit_fonts(void);
73
74 static int extra_width, extra_height;
75
76 static int pending_netevent = 0;
77 static WPARAM pend_netevent_wParam = 0;
78 static LPARAM pend_netevent_lParam = 0;
79 static void enact_pending_netevent(void);
80 static void flash_window(int mode);
81
82 static time_t last_movement = 0;
83
84 #define FONT_NORMAL 0
85 #define FONT_BOLD 1
86 #define FONT_UNDERLINE 2
87 #define FONT_BOLDUND 3
88 #define FONT_WIDE 0x04
89 #define FONT_HIGH 0x08
90 #define FONT_NARROW 0x10
91 #define FONT_OEM 0x20
92 #define FONT_OEMBOLD 0x21
93 #define FONT_OEMUND 0x22
94 #define FONT_OEMBOLDUND 0x23
95 #define FONT_MSGOTHIC 0x40
96 #define FONT_MINGLIU 0x60
97 #define FONT_GULIMCHE 0x80
98 #define FONT_MAXNO 0x8F
99 #define FONT_SHIFT 5
100 static HFONT fonts[FONT_MAXNO];
101 static int fontflag[FONT_MAXNO];
102 static enum {
103 BOLD_COLOURS, BOLD_SHADOW, BOLD_FONT
104 } bold_mode;
105 static enum {
106 UND_LINE, UND_FONT
107 } und_mode;
108 static int descent;
109
110 #define NCOLOURS 24
111 static COLORREF colours[NCOLOURS];
112 static HPALETTE pal;
113 static LPLOGPALETTE logpal;
114 static RGBTRIPLE defpal[NCOLOURS];
115
116 static HWND hwnd;
117
118 static HBITMAP caretbm;
119
120 static int dbltime, lasttime, lastact;
121 static Mouse_Button lastbtn;
122
123 /* this allows xterm-style mouse handling. */
124 static int send_raw_mouse = 0;
125 static int wheel_accumulator = 0;
126
127 static char *window_name, *icon_name;
128
129 static int compose_state = 0;
130
131 static OSVERSIONINFO osVersion;
132
133 /* Dummy routine, only required in plink. */
134 void ldisc_update(int echo, int edit)
135 {
136 }
137
138 int WINAPI WinMain(HINSTANCE inst, HINSTANCE prev, LPSTR cmdline, int show)
139 {
140 static char appname[] = "PuTTY";
141 WORD winsock_ver;
142 WSADATA wsadata;
143 WNDCLASS wndclass;
144 MSG msg;
145 int guess_width, guess_height;
146
147 hinst = inst;
148 flags = FLAG_VERBOSE | FLAG_INTERACTIVE;
149
150 winsock_ver = MAKEWORD(1, 1);
151 if (WSAStartup(winsock_ver, &wsadata)) {
152 MessageBox(NULL, "Unable to initialise WinSock", "WinSock Error",
153 MB_OK | MB_ICONEXCLAMATION);
154 return 1;
155 }
156 if (LOBYTE(wsadata.wVersion) != 1 || HIBYTE(wsadata.wVersion) != 1) {
157 MessageBox(NULL, "WinSock version is incompatible with 1.1",
158 "WinSock Error", MB_OK | MB_ICONEXCLAMATION);
159 WSACleanup();
160 return 1;
161 }
162 /* WISHLIST: maybe allow config tweaking even if winsock not present? */
163 sk_init();
164
165 InitCommonControls();
166
167 /* Ensure a Maximize setting in Explorer doesn't maximise the
168 * config box. */
169 defuse_showwindow();
170
171 {
172 ZeroMemory(&osVersion, sizeof(osVersion));
173 osVersion.dwOSVersionInfoSize = sizeof (OSVERSIONINFO);
174 if (!GetVersionEx ( (OSVERSIONINFO *) &osVersion)) {
175 MessageBox(NULL, "Windows refuses to report a version",
176 "PuTTY Fatal Error", MB_OK | MB_ICONEXCLAMATION);
177 return 1;
178 }
179 }
180
181 /*
182 * Process the command line.
183 */
184 {
185 char *p;
186
187 default_protocol = DEFAULT_PROTOCOL;
188 default_port = DEFAULT_PORT;
189 cfg.logtype = LGTYP_NONE;
190
191 do_defaults(NULL, &cfg);
192
193 p = cmdline;
194 while (*p && isspace(*p))
195 p++;
196
197 /*
198 * Process command line options first. Yes, this can be
199 * done better, and it will be as soon as I have the
200 * energy...
201 */
202 while (*p == '-') {
203 char *q = p + strcspn(p, " \t");
204 p++;
205 if (q == p + 3 &&
206 tolower(p[0]) == 's' &&
207 tolower(p[1]) == 's' && tolower(p[2]) == 'h') {
208 default_protocol = cfg.protocol = PROT_SSH;
209 default_port = cfg.port = 22;
210 } else if (q == p + 7 &&
211 tolower(p[0]) == 'c' &&
212 tolower(p[1]) == 'l' &&
213 tolower(p[2]) == 'e' &&
214 tolower(p[3]) == 'a' &&
215 tolower(p[4]) == 'n' &&
216 tolower(p[5]) == 'u' && tolower(p[6]) == 'p') {
217 /*
218 * `putty -cleanup'. Remove all registry entries
219 * associated with PuTTY, and also find and delete
220 * the random seed file.
221 */
222 if (MessageBox(NULL,
223 "This procedure will remove ALL Registry\n"
224 "entries associated with PuTTY, and will\n"
225 "also remove the PuTTY random seed file.\n"
226 "\n"
227 "THIS PROCESS WILL DESTROY YOUR SAVED\n"
228 "SESSIONS. Are you really sure you want\n"
229 "to continue?",
230 "PuTTY Warning",
231 MB_YESNO | MB_ICONWARNING) == IDYES) {
232 cleanup_all();
233 }
234 exit(0);
235 }
236 p = q + strspn(q, " \t");
237 }
238
239 /*
240 * An initial @ means to activate a saved session.
241 */
242 if (*p == '@') {
243 int i = strlen(p);
244 while (i > 1 && isspace(p[i - 1]))
245 i--;
246 p[i] = '\0';
247 do_defaults(p + 1, &cfg);
248 if (!*cfg.host && !do_config()) {
249 WSACleanup();
250 return 0;
251 }
252 } else if (*p == '&') {
253 /*
254 * An initial & means we've been given a command line
255 * containing the hex value of a HANDLE for a file
256 * mapping object, which we must then extract as a
257 * config.
258 */
259 HANDLE filemap;
260 Config *cp;
261 if (sscanf(p + 1, "%p", &filemap) == 1 &&
262 (cp = MapViewOfFile(filemap, FILE_MAP_READ,
263 0, 0, sizeof(Config))) != NULL) {
264 cfg = *cp;
265 UnmapViewOfFile(cp);
266 CloseHandle(filemap);
267 } else if (!do_config()) {
268 WSACleanup();
269 return 0;
270 }
271 } else if (*p) {
272 char *q = p;
273 /*
274 * If the hostname starts with "telnet:", set the
275 * protocol to Telnet and process the string as a
276 * Telnet URL.
277 */
278 if (!strncmp(q, "telnet:", 7)) {
279 char c;
280
281 q += 7;
282 if (q[0] == '/' && q[1] == '/')
283 q += 2;
284 cfg.protocol = PROT_TELNET;
285 p = q;
286 while (*p && *p != ':' && *p != '/')
287 p++;
288 c = *p;
289 if (*p)
290 *p++ = '\0';
291 if (c == ':')
292 cfg.port = atoi(p);
293 else
294 cfg.port = -1;
295 strncpy(cfg.host, q, sizeof(cfg.host) - 1);
296 cfg.host[sizeof(cfg.host) - 1] = '\0';
297 } else {
298 while (*p && !isspace(*p))
299 p++;
300 if (*p)
301 *p++ = '\0';
302 strncpy(cfg.host, q, sizeof(cfg.host) - 1);
303 cfg.host[sizeof(cfg.host) - 1] = '\0';
304 while (*p && isspace(*p))
305 p++;
306 if (*p)
307 cfg.port = atoi(p);
308 else
309 cfg.port = -1;
310 }
311 } else {
312 if (!do_config()) {
313 WSACleanup();
314 return 0;
315 }
316 }
317
318 /*
319 * Trim leading whitespace off the hostname if it's there.
320 */
321 {
322 int space = strspn(cfg.host, " \t");
323 memmove(cfg.host, cfg.host+space, 1+strlen(cfg.host)-space);
324 }
325
326 /* See if host is of the form user@host */
327 if (cfg.host[0] != '\0') {
328 char *atsign = strchr(cfg.host, '@');
329 /* Make sure we're not overflowing the user field */
330 if (atsign) {
331 if (atsign - cfg.host < sizeof cfg.username) {
332 strncpy(cfg.username, cfg.host, atsign - cfg.host);
333 cfg.username[atsign - cfg.host] = '\0';
334 }
335 memmove(cfg.host, atsign + 1, 1 + strlen(atsign + 1));
336 }
337 }
338
339 /*
340 * Trim a colon suffix off the hostname if it's there.
341 */
342 cfg.host[strcspn(cfg.host, ":")] = '\0';
343 }
344
345 /*
346 * Select protocol. This is farmed out into a table in a
347 * separate file to enable an ssh-free variant.
348 */
349 {
350 int i;
351 back = NULL;
352 for (i = 0; backends[i].backend != NULL; i++)
353 if (backends[i].protocol == cfg.protocol) {
354 back = backends[i].backend;
355 break;
356 }
357 if (back == NULL) {
358 MessageBox(NULL, "Unsupported protocol number found",
359 "PuTTY Internal Error", MB_OK | MB_ICONEXCLAMATION);
360 WSACleanup();
361 return 1;
362 }
363 }
364
365 /* Check for invalid Port number (i.e. zero) */
366 if (cfg.port == 0) {
367 MessageBox(NULL, "Invalid Port Number",
368 "PuTTY Internal Error", MB_OK | MB_ICONEXCLAMATION);
369 WSACleanup();
370 return 1;
371 }
372
373 if (!prev) {
374 wndclass.style = 0;
375 wndclass.lpfnWndProc = WndProc;
376 wndclass.cbClsExtra = 0;
377 wndclass.cbWndExtra = 0;
378 wndclass.hInstance = inst;
379 wndclass.hIcon = LoadIcon(inst, MAKEINTRESOURCE(IDI_MAINICON));
380 wndclass.hCursor = LoadCursor(NULL, IDC_IBEAM);
381 wndclass.hbrBackground = GetStockObject(BLACK_BRUSH);
382 wndclass.lpszMenuName = NULL;
383 wndclass.lpszClassName = appname;
384
385 RegisterClass(&wndclass);
386 }
387
388 hwnd = NULL;
389
390 savelines = cfg.savelines;
391 term_init();
392
393 cfgtopalette();
394
395 /*
396 * Guess some defaults for the window size. This all gets
397 * updated later, so we don't really care too much. However, we
398 * do want the font width/height guesses to correspond to a
399 * large font rather than a small one...
400 */
401
402 font_width = 10;
403 font_height = 20;
404 extra_width = 25;
405 extra_height = 28;
406 term_size(cfg.height, cfg.width, cfg.savelines);
407 guess_width = extra_width + font_width * cols;
408 guess_height = extra_height + font_height * rows;
409 {
410 RECT r;
411 HWND w = GetDesktopWindow();
412 GetWindowRect(w, &r);
413 if (guess_width > r.right - r.left)
414 guess_width = r.right - r.left;
415 if (guess_height > r.bottom - r.top)
416 guess_height = r.bottom - r.top;
417 }
418
419 {
420 int winmode = WS_OVERLAPPEDWINDOW | WS_VSCROLL;
421 int exwinmode = 0;
422 if (!cfg.scrollbar)
423 winmode &= ~(WS_VSCROLL);
424 if (cfg.locksize)
425 winmode &= ~(WS_THICKFRAME | WS_MAXIMIZEBOX);
426 if (cfg.alwaysontop)
427 exwinmode |= WS_EX_TOPMOST;
428 if (cfg.sunken_edge)
429 exwinmode |= WS_EX_CLIENTEDGE;
430 hwnd = CreateWindowEx(exwinmode, appname, appname,
431 winmode, CW_USEDEFAULT, CW_USEDEFAULT,
432 guess_width, guess_height,
433 NULL, NULL, inst, NULL);
434 }
435
436 /*
437 * Initialise the fonts, simultaneously correcting the guesses
438 * for font_{width,height}.
439 */
440 bold_mode = cfg.bold_colour ? BOLD_COLOURS : BOLD_FONT;
441 und_mode = UND_FONT;
442 init_fonts(0);
443
444 /*
445 * Correct the guesses for extra_{width,height}.
446 */
447 {
448 RECT cr, wr;
449 GetWindowRect(hwnd, &wr);
450 GetClientRect(hwnd, &cr);
451 extra_width = wr.right - wr.left - cr.right + cr.left;
452 extra_height = wr.bottom - wr.top - cr.bottom + cr.top;
453 }
454
455 /*
456 * Resize the window, now we know what size we _really_ want it
457 * to be.
458 */
459 guess_width = extra_width + font_width * cols;
460 guess_height = extra_height + font_height * rows;
461 SendMessage(hwnd, WM_IGNORE_SIZE, 0, 0);
462 SetWindowPos(hwnd, NULL, 0, 0, guess_width, guess_height,
463 SWP_NOMOVE | SWP_NOREDRAW | SWP_NOZORDER);
464
465 /*
466 * Set up a caret bitmap, with no content.
467 */
468 {
469 char *bits;
470 int size = (font_width + 15) / 16 * 2 * font_height;
471 bits = smalloc(size);
472 memset(bits, 0, size);
473 caretbm = CreateBitmap(font_width, font_height, 1, 1, bits);
474 sfree(bits);
475 }
476 CreateCaret(hwnd, caretbm, font_width, font_height);
477
478 /*
479 * Initialise the scroll bar.
480 */
481 {
482 SCROLLINFO si;
483
484 si.cbSize = sizeof(si);
485 si.fMask = SIF_ALL | SIF_DISABLENOSCROLL;
486 si.nMin = 0;
487 si.nMax = rows - 1;
488 si.nPage = rows;
489 si.nPos = 0;
490 SetScrollInfo(hwnd, SB_VERT, &si, FALSE);
491 }
492
493 /*
494 * Start up the telnet connection.
495 */
496 {
497 char *error;
498 char msg[1024], *title;
499 char *realhost;
500
501 error = back->init(cfg.host, cfg.port, &realhost);
502 if (error) {
503 sprintf(msg, "Unable to open connection to\n"
504 "%.800s\n" "%s", cfg.host, error);
505 MessageBox(NULL, msg, "PuTTY Error", MB_ICONERROR | MB_OK);
506 return 0;
507 }
508 window_name = icon_name = NULL;
509 if (*cfg.wintitle) {
510 title = cfg.wintitle;
511 } else {
512 sprintf(msg, "%s - PuTTY", realhost);
513 title = msg;
514 }
515 sfree(realhost);
516 set_title(title);
517 set_icon(title);
518 }
519
520 session_closed = FALSE;
521
522 /*
523 * Set up the input and output buffers.
524 */
525 inbuf_head = 0;
526 outbuf_reap = outbuf_head = 0;
527
528 /*
529 * Prepare the mouse handler.
530 */
531 lastact = MA_NOTHING;
532 lastbtn = MBT_NOTHING;
533 dbltime = GetDoubleClickTime();
534
535 /*
536 * Set up the session-control options on the system menu.
537 */
538 {
539 HMENU m = GetSystemMenu(hwnd, FALSE);
540 HMENU p, s;
541 int i;
542
543 AppendMenu(m, MF_SEPARATOR, 0, 0);
544 if (cfg.protocol == PROT_TELNET) {
545 p = CreateMenu();
546 AppendMenu(p, MF_ENABLED, IDM_TEL_AYT, "Are You There");
547 AppendMenu(p, MF_ENABLED, IDM_TEL_BRK, "Break");
548 AppendMenu(p, MF_ENABLED, IDM_TEL_SYNCH, "Synch");
549 AppendMenu(p, MF_SEPARATOR, 0, 0);
550 AppendMenu(p, MF_ENABLED, IDM_TEL_EC, "Erase Character");
551 AppendMenu(p, MF_ENABLED, IDM_TEL_EL, "Erase Line");
552 AppendMenu(p, MF_ENABLED, IDM_TEL_GA, "Go Ahead");
553 AppendMenu(p, MF_ENABLED, IDM_TEL_NOP, "No Operation");
554 AppendMenu(p, MF_SEPARATOR, 0, 0);
555 AppendMenu(p, MF_ENABLED, IDM_TEL_ABORT, "Abort Process");
556 AppendMenu(p, MF_ENABLED, IDM_TEL_AO, "Abort Output");
557 AppendMenu(p, MF_ENABLED, IDM_TEL_IP, "Interrupt Process");
558 AppendMenu(p, MF_ENABLED, IDM_TEL_SUSP, "Suspend Process");
559 AppendMenu(p, MF_SEPARATOR, 0, 0);
560 AppendMenu(p, MF_ENABLED, IDM_TEL_EOR, "End Of Record");
561 AppendMenu(p, MF_ENABLED, IDM_TEL_EOF, "End Of File");
562 AppendMenu(m, MF_POPUP | MF_ENABLED, (UINT) p,
563 "Telnet Command");
564 AppendMenu(m, MF_SEPARATOR, 0, 0);
565 }
566 AppendMenu(m, MF_ENABLED, IDM_SHOWLOG, "&Event Log");
567 AppendMenu(m, MF_SEPARATOR, 0, 0);
568 AppendMenu(m, MF_ENABLED, IDM_NEWSESS, "Ne&w Session...");
569 AppendMenu(m, MF_ENABLED, IDM_DUPSESS, "&Duplicate Session");
570 s = CreateMenu();
571 get_sesslist(TRUE);
572 for (i = 1; i < ((nsessions < 256) ? nsessions : 256); i++)
573 AppendMenu(s, MF_ENABLED, IDM_SAVED_MIN + (16 * i),
574 sessions[i]);
575 AppendMenu(m, MF_POPUP | MF_ENABLED, (UINT) s, "Sa&ved Sessions");
576 AppendMenu(m, MF_ENABLED, IDM_RECONF, "Chan&ge Settings...");
577 AppendMenu(m, MF_SEPARATOR, 0, 0);
578 AppendMenu(m, MF_ENABLED, IDM_COPYALL, "C&opy All to Clipboard");
579 AppendMenu(m, MF_ENABLED, IDM_CLRSB, "C&lear Scrollback");
580 AppendMenu(m, MF_ENABLED, IDM_RESET, "Rese&t Terminal");
581 AppendMenu(m, MF_SEPARATOR, 0, 0);
582 AppendMenu(m, MF_ENABLED, IDM_ABOUT, "&About PuTTY");
583 }
584
585 /*
586 * Finally show the window!
587 */
588 ShowWindow(hwnd, show);
589 SetForegroundWindow(hwnd);
590
591 /*
592 * Open the initial log file if there is one.
593 */
594 logfopen();
595
596 /*
597 * Set the palette up.
598 */
599 pal = NULL;
600 logpal = NULL;
601 init_palette();
602
603 has_focus = (GetForegroundWindow() == hwnd);
604 UpdateWindow(hwnd);
605
606 if (GetMessage(&msg, NULL, 0, 0) == 1) {
607 int timer_id = 0, long_timer = 0;
608
609 while (msg.message != WM_QUIT) {
610 /* Sometimes DispatchMessage calls routines that use their own
611 * GetMessage loop, setup this timer so we get some control back.
612 *
613 * Also call term_update() from the timer so that if the host
614 * is sending data flat out we still do redraws.
615 */
616 if (timer_id && long_timer) {
617 KillTimer(hwnd, timer_id);
618 long_timer = timer_id = 0;
619 }
620 if (!timer_id)
621 timer_id = SetTimer(hwnd, 1, 20, NULL);
622 if (!(IsWindow(logbox) && IsDialogMessage(logbox, &msg)))
623 DispatchMessage(&msg);
624
625 /* Make sure we blink everything that needs it. */
626 term_blink(0);
627
628 /* Send the paste buffer if there's anything to send */
629 term_paste();
630
631 /* If there's nothing new in the queue then we can do everything
632 * we've delayed, reading the socket, writing, and repainting
633 * the window.
634 */
635 if (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))
636 continue;
637
638 if (pending_netevent) {
639 enact_pending_netevent();
640
641 /* Force the cursor blink on */
642 term_blink(1);
643
644 if (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))
645 continue;
646 }
647
648 /* Okay there is now nothing to do so we make sure the screen is
649 * completely up to date then tell windows to call us in a little
650 * while.
651 */
652 if (timer_id) {
653 KillTimer(hwnd, timer_id);
654 timer_id = 0;
655 }
656 HideCaret(hwnd);
657 if (inbuf_head)
658 term_out();
659 term_update();
660 ShowCaret(hwnd);
661
662 flash_window(1); /* maintain */
663
664 if (in_vbell)
665 /* Hmm, term_update didn't want to do an update too soon ... */
666 timer_id = SetTimer(hwnd, 1, 50, NULL);
667 else if (!has_focus)
668 timer_id = SetTimer(hwnd, 1, 500, NULL);
669 else
670 timer_id = SetTimer(hwnd, 1, 100, NULL);
671 long_timer = 1;
672
673 /* There's no point rescanning everything in the message queue
674 * so we do an apparently unnecessary wait here
675 */
676 WaitMessage();
677 if (GetMessage(&msg, NULL, 0, 0) != 1)
678 break;
679 }
680 }
681
682 /*
683 * Clean up.
684 */
685 deinit_fonts();
686 sfree(logpal);
687 if (pal)
688 DeleteObject(pal);
689 WSACleanup();
690
691 if (cfg.protocol == PROT_SSH) {
692 random_save_seed();
693 #ifdef MSCRYPTOAPI
694 crypto_wrapup();
695 #endif
696 }
697
698 return msg.wParam;
699 }
700
701 /*
702 * Set up, or shut down, an AsyncSelect. Called from winnet.c.
703 */
704 char *do_select(SOCKET skt, int startup)
705 {
706 int msg, events;
707 if (startup) {
708 msg = WM_NETEVENT;
709 events = FD_READ | FD_WRITE | FD_OOB | FD_CLOSE | FD_ACCEPT;
710 } else {
711 msg = events = 0;
712 }
713 if (!hwnd)
714 return "do_select(): internal error (hwnd==NULL)";
715 if (WSAAsyncSelect(skt, hwnd, msg, events) == SOCKET_ERROR) {
716 switch (WSAGetLastError()) {
717 case WSAENETDOWN:
718 return "Network is down";
719 default:
720 return "WSAAsyncSelect(): unknown error";
721 }
722 }
723 return NULL;
724 }
725
726 /*
727 * set or clear the "raw mouse message" mode
728 */
729 void set_raw_mouse_mode(int activate)
730 {
731 send_raw_mouse = activate;
732 SetCursor(LoadCursor(NULL, activate ? IDC_ARROW : IDC_IBEAM));
733 }
734
735 /*
736 * Print a message box and close the connection.
737 */
738 void connection_fatal(char *fmt, ...)
739 {
740 va_list ap;
741 char stuff[200];
742
743 va_start(ap, fmt);
744 vsprintf(stuff, fmt, ap);
745 va_end(ap);
746 MessageBox(hwnd, stuff, "PuTTY Fatal Error", MB_ICONERROR | MB_OK);
747 if (cfg.close_on_exit == COE_ALWAYS)
748 PostQuitMessage(1);
749 else {
750 session_closed = TRUE;
751 SetWindowText(hwnd, "PuTTY (inactive)");
752 }
753 }
754
755 /*
756 * Actually do the job requested by a WM_NETEVENT
757 */
758 static void enact_pending_netevent(void)
759 {
760 static int reentering = 0;
761 extern int select_result(WPARAM, LPARAM);
762 int ret;
763
764 if (reentering)
765 return; /* don't unpend the pending */
766
767 pending_netevent = FALSE;
768
769 reentering = 1;
770 ret = select_result(pend_netevent_wParam, pend_netevent_lParam);
771 reentering = 0;
772
773 if (ret == 0 && !session_closed) {
774 /* Abnormal exits will already have set session_closed and taken
775 * appropriate action. */
776 if (cfg.close_on_exit == COE_ALWAYS ||
777 cfg.close_on_exit == COE_NORMAL) PostQuitMessage(0);
778 else {
779 session_closed = TRUE;
780 SetWindowText(hwnd, "PuTTY (inactive)");
781 MessageBox(hwnd, "Connection closed by remote host",
782 "PuTTY", MB_OK | MB_ICONINFORMATION);
783 }
784 }
785 }
786
787 /*
788 * Copy the colour palette from the configuration data into defpal.
789 * This is non-trivial because the colour indices are different.
790 */
791 static void cfgtopalette(void)
792 {
793 int i;
794 static const int ww[] = {
795 6, 7, 8, 9, 10, 11, 12, 13,
796 14, 15, 16, 17, 18, 19, 20, 21,
797 0, 1, 2, 3, 4, 4, 5, 5
798 };
799
800 for (i = 0; i < 24; i++) {
801 int w = ww[i];
802 defpal[i].rgbtRed = cfg.colours[w][0];
803 defpal[i].rgbtGreen = cfg.colours[w][1];
804 defpal[i].rgbtBlue = cfg.colours[w][2];
805 }
806 }
807
808 /*
809 * Set up the colour palette.
810 */
811 static void init_palette(void)
812 {
813 int i;
814 HDC hdc = GetDC(hwnd);
815 if (hdc) {
816 if (cfg.try_palette && GetDeviceCaps(hdc, RASTERCAPS) & RC_PALETTE) {
817 logpal = smalloc(sizeof(*logpal)
818 - sizeof(logpal->palPalEntry)
819 + NCOLOURS * sizeof(PALETTEENTRY));
820 logpal->palVersion = 0x300;
821 logpal->palNumEntries = NCOLOURS;
822 for (i = 0; i < NCOLOURS; i++) {
823 logpal->palPalEntry[i].peRed = defpal[i].rgbtRed;
824 logpal->palPalEntry[i].peGreen = defpal[i].rgbtGreen;
825 logpal->palPalEntry[i].peBlue = defpal[i].rgbtBlue;
826 logpal->palPalEntry[i].peFlags = PC_NOCOLLAPSE;
827 }
828 pal = CreatePalette(logpal);
829 if (pal) {
830 SelectPalette(hdc, pal, FALSE);
831 RealizePalette(hdc);
832 SelectPalette(hdc, GetStockObject(DEFAULT_PALETTE), FALSE);
833 }
834 }
835 ReleaseDC(hwnd, hdc);
836 }
837 if (pal)
838 for (i = 0; i < NCOLOURS; i++)
839 colours[i] = PALETTERGB(defpal[i].rgbtRed,
840 defpal[i].rgbtGreen,
841 defpal[i].rgbtBlue);
842 else
843 for (i = 0; i < NCOLOURS; i++)
844 colours[i] = RGB(defpal[i].rgbtRed,
845 defpal[i].rgbtGreen, defpal[i].rgbtBlue);
846 }
847
848 /*
849 * Initialise all the fonts we will need initially. There may be as many as
850 * three or as few as one. The other (poentially) twentyone fonts are done
851 * if/when they are needed.
852 *
853 * We also:
854 *
855 * - check the font width and height, correcting our guesses if
856 * necessary.
857 *
858 * - verify that the bold font is the same width as the ordinary
859 * one, and engage shadow bolding if not.
860 *
861 * - verify that the underlined font is the same width as the
862 * ordinary one (manual underlining by means of line drawing can
863 * be done in a pinch).
864 */
865 static void init_fonts(int pick_width)
866 {
867 TEXTMETRIC tm;
868 CPINFO cpinfo;
869 int fontsize[3];
870 int i;
871 HDC hdc;
872 int fw_dontcare, fw_bold;
873
874 for (i = 0; i < FONT_MAXNO; i++)
875 fonts[i] = NULL;
876
877 if (cfg.fontisbold) {
878 fw_dontcare = FW_BOLD;
879 fw_bold = FW_HEAVY;
880 } else {
881 fw_dontcare = FW_DONTCARE;
882 fw_bold = FW_BOLD;
883 }
884
885 hdc = GetDC(hwnd);
886
887 font_height = cfg.fontheight;
888 if (font_height > 0) {
889 font_height =
890 -MulDiv(font_height, GetDeviceCaps(hdc, LOGPIXELSY), 72);
891 }
892 font_width = pick_width;
893
894 #define f(i,c,w,u) \
895 fonts[i] = CreateFont (font_height, font_width, 0, 0, w, FALSE, u, FALSE, \
896 c, OUT_DEFAULT_PRECIS, \
897 CLIP_DEFAULT_PRECIS, DEFAULT_QUALITY, \
898 FIXED_PITCH | FF_DONTCARE, cfg.font)
899
900 f(FONT_NORMAL, cfg.fontcharset, fw_dontcare, FALSE);
901
902 SelectObject(hdc, fonts[FONT_NORMAL]);
903 GetTextMetrics(hdc, &tm);
904 font_height = tm.tmHeight;
905 font_width = tm.tmAveCharWidth;
906
907 {
908 CHARSETINFO info;
909 DWORD cset = tm.tmCharSet;
910 memset(&info, 0xFF, sizeof(info));
911
912 /* !!! Yes the next line is right */
913 if (cset == OEM_CHARSET)
914 font_codepage = GetOEMCP();
915 else
916 if (TranslateCharsetInfo
917 ((DWORD *) cset, &info, TCI_SRCCHARSET)) font_codepage =
918 info.ciACP;
919 else
920 font_codepage = -1;
921
922 GetCPInfo(font_codepage, &cpinfo);
923 dbcs_screenfont = (cpinfo.MaxCharSize > 1);
924 }
925
926 f(FONT_UNDERLINE, cfg.fontcharset, fw_dontcare, TRUE);
927
928 /*
929 * Some fonts, e.g. 9-pt Courier, draw their underlines
930 * outside their character cell. We successfully prevent
931 * screen corruption by clipping the text output, but then
932 * we lose the underline completely. Here we try to work
933 * out whether this is such a font, and if it is, we set a
934 * flag that causes underlines to be drawn by hand.
935 *
936 * Having tried other more sophisticated approaches (such
937 * as examining the TEXTMETRIC structure or requesting the
938 * height of a string), I think we'll do this the brute
939 * force way: we create a small bitmap, draw an underlined
940 * space on it, and test to see whether any pixels are
941 * foreground-coloured. (Since we expect the underline to
942 * go all the way across the character cell, we only search
943 * down a single column of the bitmap, half way across.)
944 */
945 {
946 HDC und_dc;
947 HBITMAP und_bm, und_oldbm;
948 int i, gotit;
949 COLORREF c;
950
951 und_dc = CreateCompatibleDC(hdc);
952 und_bm = CreateCompatibleBitmap(hdc, font_width, font_height);
953 und_oldbm = SelectObject(und_dc, und_bm);
954 SelectObject(und_dc, fonts[FONT_UNDERLINE]);
955 SetTextAlign(und_dc, TA_TOP | TA_LEFT | TA_NOUPDATECP);
956 SetTextColor(und_dc, RGB(255, 255, 255));
957 SetBkColor(und_dc, RGB(0, 0, 0));
958 SetBkMode(und_dc, OPAQUE);
959 ExtTextOut(und_dc, 0, 0, ETO_OPAQUE, NULL, " ", 1, NULL);
960 gotit = FALSE;
961 for (i = 0; i < font_height; i++) {
962 c = GetPixel(und_dc, font_width / 2, i);
963 if (c != RGB(0, 0, 0))
964 gotit = TRUE;
965 }
966 SelectObject(und_dc, und_oldbm);
967 DeleteObject(und_bm);
968 DeleteDC(und_dc);
969 if (!gotit) {
970 und_mode = UND_LINE;
971 DeleteObject(fonts[FONT_UNDERLINE]);
972 fonts[FONT_UNDERLINE] = 0;
973 }
974 }
975
976 if (bold_mode == BOLD_FONT) {
977 f(FONT_BOLD, cfg.fontcharset, fw_bold, FALSE);
978 }
979 #undef f
980
981 descent = tm.tmAscent + 1;
982 if (descent >= font_height)
983 descent = font_height - 1;
984
985 for (i = 0; i < 3; i++) {
986 if (fonts[i]) {
987 if (SelectObject(hdc, fonts[i]) && GetTextMetrics(hdc, &tm))
988 fontsize[i] = tm.tmAveCharWidth + 256 * tm.tmHeight;
989 else
990 fontsize[i] = -i;
991 } else
992 fontsize[i] = -i;
993 }
994
995 ReleaseDC(hwnd, hdc);
996
997 if (fontsize[FONT_UNDERLINE] != fontsize[FONT_NORMAL]) {
998 und_mode = UND_LINE;
999 DeleteObject(fonts[FONT_UNDERLINE]);
1000 fonts[FONT_UNDERLINE] = 0;
1001 }
1002
1003 if (bold_mode == BOLD_FONT &&
1004 fontsize[FONT_BOLD] != fontsize[FONT_NORMAL]) {
1005 bold_mode = BOLD_SHADOW;
1006 DeleteObject(fonts[FONT_BOLD]);
1007 fonts[FONT_BOLD] = 0;
1008 }
1009 fontflag[0] = fontflag[1] = fontflag[2] = 1;
1010
1011 init_ucs_tables();
1012 }
1013
1014 static void another_font(int fontno)
1015 {
1016 int basefont;
1017 int fw_dontcare, fw_bold;
1018 int c, u, w, x;
1019 char *s;
1020
1021 if (fontno < 0 || fontno >= FONT_MAXNO || fontflag[fontno])
1022 return;
1023
1024 basefont = (fontno & ~(FONT_BOLDUND));
1025 if (basefont != fontno && !fontflag[basefont])
1026 another_font(basefont);
1027
1028 if (cfg.fontisbold) {
1029 fw_dontcare = FW_BOLD;
1030 fw_bold = FW_HEAVY;
1031 } else {
1032 fw_dontcare = FW_DONTCARE;
1033 fw_bold = FW_BOLD;
1034 }
1035
1036 c = cfg.fontcharset;
1037 w = fw_dontcare;
1038 u = FALSE;
1039 s = cfg.font;
1040 x = font_width;
1041
1042 if (fontno & FONT_WIDE)
1043 x *= 2;
1044 if (fontno & FONT_NARROW)
1045 x /= 2;
1046 if (fontno & FONT_OEM)
1047 c = OEM_CHARSET;
1048 if (fontno & FONT_BOLD)
1049 w = fw_bold;
1050 if (fontno & FONT_UNDERLINE)
1051 u = TRUE;
1052
1053 fonts[fontno] =
1054 CreateFont(font_height * (1 + !!(fontno & FONT_HIGH)), x, 0, 0, w,
1055 FALSE, u, FALSE, c, OUT_DEFAULT_PRECIS,
1056 CLIP_DEFAULT_PRECIS, DEFAULT_QUALITY,
1057 FIXED_PITCH | FF_DONTCARE, s);
1058
1059 fontflag[fontno] = 1;
1060 }
1061
1062 static void deinit_fonts(void)
1063 {
1064 int i;
1065 for (i = 0; i < FONT_MAXNO; i++) {
1066 if (fonts[i])
1067 DeleteObject(fonts[i]);
1068 fonts[i] = 0;
1069 fontflag[i] = 0;
1070 }
1071 }
1072
1073 void request_resize(int w, int h, int refont)
1074 {
1075 int width, height;
1076
1077 /* If the window is maximized supress resizing attempts */
1078 if (IsZoomed(hwnd))
1079 return;
1080
1081 if (refont && w != cols && (cols == 80 || cols == 132)) {
1082 /* If font width too big for screen should we shrink the font more ? */
1083 if (w == 132)
1084 font_width = ((font_width * cols + w / 2) / w);
1085 else
1086 font_width = 0;
1087 deinit_fonts();
1088 bold_mode = cfg.bold_colour ? BOLD_COLOURS : BOLD_FONT;
1089 und_mode = UND_FONT;
1090 init_fonts(font_width);
1091 } else {
1092 static int first_time = 1;
1093 static RECT ss;
1094
1095 switch (first_time) {
1096 case 1:
1097 /* Get the size of the screen */
1098 if (GetClientRect(GetDesktopWindow(), &ss))
1099 /* first_time = 0 */ ;
1100 else {
1101 first_time = 2;
1102 break;
1103 }
1104 case 0:
1105 /* Make sure the values are sane */
1106 width = (ss.right - ss.left - extra_width) / font_width;
1107 height = (ss.bottom - ss.top - extra_height) / font_height;
1108
1109 if (w > width)
1110 w = width;
1111 if (h > height)
1112 h = height;
1113 if (w < 15)
1114 w = 15;
1115 if (h < 1)
1116 w = 1;
1117 }
1118 }
1119
1120 width = extra_width + font_width * w;
1121 height = extra_height + font_height * h;
1122
1123 SetWindowPos(hwnd, NULL, 0, 0, width, height,
1124 SWP_NOACTIVATE | SWP_NOCOPYBITS |
1125 SWP_NOMOVE | SWP_NOZORDER);
1126 }
1127
1128 static void click(Mouse_Button b, int x, int y, int shift, int ctrl)
1129 {
1130 int thistime = GetMessageTime();
1131
1132 if (send_raw_mouse) {
1133 term_mouse(b, MA_CLICK, x, y, shift, ctrl);
1134 return;
1135 }
1136
1137 if (lastbtn == b && thistime - lasttime < dbltime) {
1138 lastact = (lastact == MA_CLICK ? MA_2CLK :
1139 lastact == MA_2CLK ? MA_3CLK :
1140 lastact == MA_3CLK ? MA_CLICK : MA_NOTHING);
1141 } else {
1142 lastbtn = b;
1143 lastact = MA_CLICK;
1144 }
1145 if (lastact != MA_NOTHING)
1146 term_mouse(b, lastact, x, y, shift, ctrl);
1147 lasttime = thistime;
1148 }
1149
1150 /*
1151 * Translate a raw mouse button designation (LEFT, MIDDLE, RIGHT)
1152 * into a cooked one (SELECT, EXTEND, PASTE).
1153 */
1154 Mouse_Button translate_button(Mouse_Button button)
1155 {
1156 if (button == MBT_LEFT)
1157 return MBT_SELECT;
1158 if (button == MBT_MIDDLE)
1159 return cfg.mouse_is_xterm ? MBT_PASTE : MBT_EXTEND;
1160 if (button == MBT_RIGHT)
1161 return cfg.mouse_is_xterm ? MBT_EXTEND : MBT_PASTE;
1162 return 0; /* shouldn't happen */
1163 }
1164
1165 static void show_mouseptr(int show)
1166 {
1167 static int cursor_visible = 1;
1168 if (!cfg.hide_mouseptr) /* override if this feature disabled */
1169 show = 1;
1170 if (cursor_visible && !show)
1171 ShowCursor(FALSE);
1172 else if (!cursor_visible && show)
1173 ShowCursor(TRUE);
1174 cursor_visible = show;
1175 }
1176
1177 static LRESULT CALLBACK WndProc(HWND hwnd, UINT message,
1178 WPARAM wParam, LPARAM lParam)
1179 {
1180 HDC hdc;
1181 static int ignore_size = FALSE;
1182 static int ignore_clip = FALSE;
1183 static int just_reconfigged = FALSE;
1184 static int resizing = FALSE;
1185 static int need_backend_resize = FALSE;
1186 static int defered_resize = FALSE;
1187
1188 switch (message) {
1189 case WM_TIMER:
1190 if (pending_netevent)
1191 enact_pending_netevent();
1192 if (inbuf_head)
1193 term_out();
1194 noise_regular();
1195 HideCaret(hwnd);
1196 term_update();
1197 ShowCaret(hwnd);
1198 if (cfg.ping_interval > 0) {
1199 time_t now;
1200 time(&now);
1201 if (now - last_movement > cfg.ping_interval) {
1202 back->special(TS_PING);
1203 last_movement = now;
1204 }
1205 }
1206 return 0;
1207 case WM_CREATE:
1208 break;
1209 case WM_CLOSE:
1210 show_mouseptr(1);
1211 if (!cfg.warn_on_close || session_closed ||
1212 MessageBox(hwnd,
1213 "Are you sure you want to close this session?",
1214 "PuTTY Exit Confirmation",
1215 MB_ICONWARNING | MB_OKCANCEL) == IDOK)
1216 DestroyWindow(hwnd);
1217 return 0;
1218 case WM_DESTROY:
1219 show_mouseptr(1);
1220 PostQuitMessage(0);
1221 return 0;
1222 case WM_SYSCOMMAND:
1223 switch (wParam & ~0xF) { /* low 4 bits reserved to Windows */
1224 case IDM_SHOWLOG:
1225 showeventlog(hwnd);
1226 break;
1227 case IDM_NEWSESS:
1228 case IDM_DUPSESS:
1229 case IDM_SAVEDSESS:
1230 {
1231 char b[2048];
1232 char c[30], *cl;
1233 int freecl = FALSE;
1234 STARTUPINFO si;
1235 PROCESS_INFORMATION pi;
1236 HANDLE filemap = NULL;
1237
1238 if (wParam == IDM_DUPSESS) {
1239 /*
1240 * Allocate a file-mapping memory chunk for the
1241 * config structure.
1242 */
1243 SECURITY_ATTRIBUTES sa;
1244 Config *p;
1245
1246 sa.nLength = sizeof(sa);
1247 sa.lpSecurityDescriptor = NULL;
1248 sa.bInheritHandle = TRUE;
1249 filemap = CreateFileMapping((HANDLE) 0xFFFFFFFF,
1250 &sa,
1251 PAGE_READWRITE,
1252 0, sizeof(Config), NULL);
1253 if (filemap) {
1254 p = (Config *) MapViewOfFile(filemap,
1255 FILE_MAP_WRITE,
1256 0, 0, sizeof(Config));
1257 if (p) {
1258 *p = cfg; /* structure copy */
1259 UnmapViewOfFile(p);
1260 }
1261 }
1262 sprintf(c, "putty &%p", filemap);
1263 cl = c;
1264 } else if (wParam == IDM_SAVEDSESS) {
1265 char *session =
1266 sessions[(lParam - IDM_SAVED_MIN) / 16];
1267 cl = smalloc(16 + strlen(session)); /* 8, but play safe */
1268 if (!cl)
1269 cl = NULL; /* not a very important failure mode */
1270 else {
1271 sprintf(cl, "putty @%s", session);
1272 freecl = TRUE;
1273 }
1274 } else
1275 cl = NULL;
1276
1277 GetModuleFileName(NULL, b, sizeof(b) - 1);
1278 si.cb = sizeof(si);
1279 si.lpReserved = NULL;
1280 si.lpDesktop = NULL;
1281 si.lpTitle = NULL;
1282 si.dwFlags = 0;
1283 si.cbReserved2 = 0;
1284 si.lpReserved2 = NULL;
1285 CreateProcess(b, cl, NULL, NULL, TRUE,
1286 NORMAL_PRIORITY_CLASS, NULL, NULL, &si, &pi);
1287
1288 if (filemap)
1289 CloseHandle(filemap);
1290 if (freecl)
1291 sfree(cl);
1292 }
1293 break;
1294 case IDM_RECONF:
1295 {
1296 int prev_alwaysontop = cfg.alwaysontop;
1297 int prev_sunken_edge = cfg.sunken_edge;
1298 char oldlogfile[FILENAME_MAX];
1299 int oldlogtype;
1300 int need_setwpos = FALSE;
1301 int old_fwidth, old_fheight;
1302
1303 strcpy(oldlogfile, cfg.logfilename);
1304 oldlogtype = cfg.logtype;
1305 old_fwidth = font_width;
1306 old_fheight = font_height;
1307 GetWindowText(hwnd, cfg.wintitle, sizeof(cfg.wintitle));
1308
1309 if (!do_reconfig(hwnd))
1310 break;
1311
1312 if (strcmp(oldlogfile, cfg.logfilename) ||
1313 oldlogtype != cfg.logtype) {
1314 logfclose(); /* reset logging */
1315 logfopen();
1316 }
1317
1318 just_reconfigged = TRUE;
1319 deinit_fonts();
1320 bold_mode = cfg.bold_colour ? BOLD_COLOURS : BOLD_FONT;
1321 und_mode = UND_FONT;
1322 init_fonts(0);
1323 sfree(logpal);
1324 /*
1325 * Flush the line discipline's edit buffer in the
1326 * case where local editing has just been disabled.
1327 */
1328 ldisc_send(NULL, 0);
1329 if (pal)
1330 DeleteObject(pal);
1331 logpal = NULL;
1332 pal = NULL;
1333 cfgtopalette();
1334 init_palette();
1335
1336 /* Enable or disable the scroll bar, etc */
1337 {
1338 LONG nflg, flag = GetWindowLong(hwnd, GWL_STYLE);
1339 LONG nexflag, exflag =
1340 GetWindowLong(hwnd, GWL_EXSTYLE);
1341
1342 nexflag = exflag;
1343 if (cfg.alwaysontop != prev_alwaysontop) {
1344 if (cfg.alwaysontop) {
1345 nexflag |= WS_EX_TOPMOST;
1346 SetWindowPos(hwnd, HWND_TOPMOST, 0, 0, 0, 0,
1347 SWP_NOMOVE | SWP_NOSIZE);
1348 } else {
1349 nexflag &= ~(WS_EX_TOPMOST);
1350 SetWindowPos(hwnd, HWND_NOTOPMOST, 0, 0, 0, 0,
1351 SWP_NOMOVE | SWP_NOSIZE);
1352 }
1353 }
1354 if (cfg.sunken_edge)
1355 nexflag |= WS_EX_CLIENTEDGE;
1356 else
1357 nexflag &= ~(WS_EX_CLIENTEDGE);
1358
1359 nflg = flag;
1360 if (cfg.scrollbar)
1361 nflg |= WS_VSCROLL;
1362 else
1363 nflg &= ~WS_VSCROLL;
1364 if (cfg.locksize)
1365 nflg &= ~(WS_THICKFRAME | WS_MAXIMIZEBOX);
1366 else
1367 nflg |= (WS_THICKFRAME | WS_MAXIMIZEBOX);
1368
1369 if (nflg != flag || nexflag != exflag) {
1370 RECT cr, wr;
1371
1372 if (nflg != flag)
1373 SetWindowLong(hwnd, GWL_STYLE, nflg);
1374 if (nexflag != exflag)
1375 SetWindowLong(hwnd, GWL_EXSTYLE, nexflag);
1376
1377 SendMessage(hwnd, WM_IGNORE_SIZE, 0, 0);
1378
1379 SetWindowPos(hwnd, NULL, 0, 0, 0, 0,
1380 SWP_NOACTIVATE | SWP_NOCOPYBITS |
1381 SWP_NOMOVE | SWP_NOSIZE | SWP_NOZORDER
1382 | SWP_FRAMECHANGED);
1383
1384 GetWindowRect(hwnd, &wr);
1385 GetClientRect(hwnd, &cr);
1386 extra_width =
1387 wr.right - wr.left - cr.right + cr.left;
1388 extra_height =
1389 wr.bottom - wr.top - cr.bottom + cr.top;
1390 need_setwpos = TRUE;
1391 }
1392 }
1393
1394 if (cfg.height != rows ||
1395 cfg.width != cols ||
1396 old_fwidth != font_width ||
1397 old_fheight != font_height ||
1398 cfg.savelines != savelines ||
1399 cfg.sunken_edge != prev_sunken_edge)
1400 need_setwpos = TRUE;
1401
1402 if (IsZoomed(hwnd)) {
1403 int w, h;
1404 RECT cr;
1405 if (need_setwpos)
1406 defered_resize = TRUE;
1407
1408 GetClientRect(hwnd, &cr);
1409 w = cr.right - cr.left;
1410 h = cr.bottom - cr.top;
1411 w = w / font_width;
1412 if (w < 1)
1413 w = 1;
1414 h = h / font_height;
1415 if (h < 1)
1416 h = 1;
1417
1418 term_size(h, w, cfg.savelines);
1419 InvalidateRect(hwnd, NULL, TRUE);
1420 back->size();
1421 } else {
1422 term_size(cfg.height, cfg.width, cfg.savelines);
1423 InvalidateRect(hwnd, NULL, TRUE);
1424 if (need_setwpos) {
1425 SetWindowPos(hwnd, NULL, 0, 0,
1426 extra_width + font_width * cfg.width,
1427 extra_height +
1428 font_height * cfg.height,
1429 SWP_NOACTIVATE | SWP_NOCOPYBITS |
1430 SWP_NOMOVE | SWP_NOZORDER);
1431 }
1432 }
1433 /* Oops */
1434 if (cfg.locksize && IsZoomed(hwnd))
1435 force_normal(hwnd);
1436 set_title(cfg.wintitle);
1437 if (IsIconic(hwnd)) {
1438 SetWindowText(hwnd,
1439 cfg.win_name_always ? window_name :
1440 icon_name);
1441 }
1442 }
1443 break;
1444 case IDM_COPYALL:
1445 term_copyall();
1446 break;
1447 case IDM_CLRSB:
1448 term_clrsb();
1449 break;
1450 case IDM_RESET:
1451 term_pwron();
1452 break;
1453 case IDM_TEL_AYT:
1454 back->special(TS_AYT);
1455 break;
1456 case IDM_TEL_BRK:
1457 back->special(TS_BRK);
1458 break;
1459 case IDM_TEL_SYNCH:
1460 back->special(TS_SYNCH);
1461 break;
1462 case IDM_TEL_EC:
1463 back->special(TS_EC);
1464 break;
1465 case IDM_TEL_EL:
1466 back->special(TS_EL);
1467 break;
1468 case IDM_TEL_GA:
1469 back->special(TS_GA);
1470 break;
1471 case IDM_TEL_NOP:
1472 back->special(TS_NOP);
1473 break;
1474 case IDM_TEL_ABORT:
1475 back->special(TS_ABORT);
1476 break;
1477 case IDM_TEL_AO:
1478 back->special(TS_AO);
1479 break;
1480 case IDM_TEL_IP:
1481 back->special(TS_IP);
1482 break;
1483 case IDM_TEL_SUSP:
1484 back->special(TS_SUSP);
1485 break;
1486 case IDM_TEL_EOR:
1487 back->special(TS_EOR);
1488 break;
1489 case IDM_TEL_EOF:
1490 back->special(TS_EOF);
1491 break;
1492 case IDM_ABOUT:
1493 showabout(hwnd);
1494 break;
1495 default:
1496 if (wParam >= IDM_SAVED_MIN && wParam <= IDM_SAVED_MAX) {
1497 SendMessage(hwnd, WM_SYSCOMMAND, IDM_SAVEDSESS, wParam);
1498 }
1499 }
1500 break;
1501
1502 #define X_POS(l) ((int)(short)LOWORD(l))
1503 #define Y_POS(l) ((int)(short)HIWORD(l))
1504
1505 #define TO_CHR_X(x) (((x)<0 ? (x)-font_width+1 : (x)) / font_width)
1506 #define TO_CHR_Y(y) (((y)<0 ? (y)-font_height+1: (y)) / font_height)
1507 #define WHEEL_DELTA 120
1508 case WM_MOUSEWHEEL:
1509 {
1510 wheel_accumulator += (short) HIWORD(wParam);
1511 wParam = LOWORD(wParam);
1512
1513 /* process events when the threshold is reached */
1514 while (abs(wheel_accumulator) >= WHEEL_DELTA) {
1515 int b;
1516
1517 /* reduce amount for next time */
1518 if (wheel_accumulator > 0) {
1519 b = MBT_WHEEL_UP;
1520 wheel_accumulator -= WHEEL_DELTA;
1521 } else if (wheel_accumulator < 0) {
1522 b = MBT_WHEEL_DOWN;
1523 wheel_accumulator += WHEEL_DELTA;
1524 } else
1525 break;
1526
1527 if (send_raw_mouse) {
1528 /* send a mouse-down followed by a mouse up */
1529 term_mouse(b,
1530 MA_CLICK,
1531 TO_CHR_X(X_POS(lParam)),
1532 TO_CHR_Y(Y_POS(lParam)), wParam & MK_SHIFT,
1533 wParam & MK_CONTROL);
1534 term_mouse(b, MA_RELEASE, TO_CHR_X(X_POS(lParam)),
1535 TO_CHR_Y(Y_POS(lParam)), wParam & MK_SHIFT,
1536 wParam & MK_CONTROL);
1537 } else {
1538 /* trigger a scroll */
1539 term_scroll(0,
1540 b == MBT_WHEEL_UP ? -rows / 2 : rows / 2);
1541 }
1542 }
1543 return 0;
1544 }
1545 case WM_LBUTTONDOWN:
1546 case WM_MBUTTONDOWN:
1547 case WM_RBUTTONDOWN:
1548 case WM_LBUTTONUP:
1549 case WM_MBUTTONUP:
1550 case WM_RBUTTONUP:
1551 {
1552 int button, press;
1553 switch (message) {
1554 case WM_LBUTTONDOWN:
1555 button = MBT_LEFT;
1556 press = 1;
1557 break;
1558 case WM_MBUTTONDOWN:
1559 button = MBT_MIDDLE;
1560 press = 1;
1561 break;
1562 case WM_RBUTTONDOWN:
1563 button = MBT_RIGHT;
1564 press = 1;
1565 break;
1566 case WM_LBUTTONUP:
1567 button = MBT_LEFT;
1568 press = 0;
1569 break;
1570 case WM_MBUTTONUP:
1571 button = MBT_MIDDLE;
1572 press = 0;
1573 break;
1574 case WM_RBUTTONUP:
1575 button = MBT_RIGHT;
1576 press = 0;
1577 break;
1578 default:
1579 button = press = 0; /* shouldn't happen */
1580 }
1581 show_mouseptr(1);
1582 if (press) {
1583 click(button,
1584 TO_CHR_X(X_POS(lParam)), TO_CHR_Y(Y_POS(lParam)),
1585 wParam & MK_SHIFT, wParam & MK_CONTROL);
1586 SetCapture(hwnd);
1587 } else {
1588 term_mouse(button, MA_RELEASE,
1589 TO_CHR_X(X_POS(lParam)),
1590 TO_CHR_Y(Y_POS(lParam)), wParam & MK_SHIFT,
1591 wParam & MK_CONTROL);
1592 ReleaseCapture();
1593 }
1594 }
1595 return 0;
1596 case WM_MOUSEMOVE:
1597 show_mouseptr(1);
1598 /*
1599 * Add the mouse position and message time to the random
1600 * number noise.
1601 */
1602 noise_ultralight(lParam);
1603
1604 if (wParam & (MK_LBUTTON | MK_MBUTTON | MK_RBUTTON)) {
1605 Mouse_Button b;
1606 if (wParam & MK_LBUTTON)
1607 b = MBT_LEFT;
1608 else if (wParam & MK_MBUTTON)
1609 b = MBT_MIDDLE;
1610 else
1611 b = MBT_RIGHT;
1612 term_mouse(b, MA_DRAG, TO_CHR_X(X_POS(lParam)),
1613 TO_CHR_Y(Y_POS(lParam)), wParam & MK_SHIFT,
1614 wParam & MK_CONTROL);
1615 }
1616 return 0;
1617 case WM_NCMOUSEMOVE:
1618 show_mouseptr(1);
1619 noise_ultralight(lParam);
1620 return 0;
1621 case WM_IGNORE_CLIP:
1622 ignore_clip = wParam; /* don't panic on DESTROYCLIPBOARD */
1623 break;
1624 case WM_DESTROYCLIPBOARD:
1625 if (!ignore_clip)
1626 term_deselect();
1627 ignore_clip = FALSE;
1628 return 0;
1629 case WM_PAINT:
1630 {
1631 PAINTSTRUCT p;
1632 HideCaret(hwnd);
1633 hdc = BeginPaint(hwnd, &p);
1634 if (pal) {
1635 SelectPalette(hdc, pal, TRUE);
1636 RealizePalette(hdc);
1637 }
1638 term_paint(hdc, p.rcPaint.left, p.rcPaint.top,
1639 p.rcPaint.right, p.rcPaint.bottom);
1640 SelectObject(hdc, GetStockObject(SYSTEM_FONT));
1641 SelectObject(hdc, GetStockObject(WHITE_PEN));
1642 EndPaint(hwnd, &p);
1643 ShowCaret(hwnd);
1644 }
1645 return 0;
1646 case WM_NETEVENT:
1647 /* Notice we can get multiple netevents, FD_READ, FD_WRITE etc
1648 * but the only one that's likely to try to overload us is FD_READ.
1649 * This means buffering just one is fine.
1650 */
1651 if (pending_netevent)
1652 enact_pending_netevent();
1653
1654 pending_netevent = TRUE;
1655 pend_netevent_wParam = wParam;
1656 pend_netevent_lParam = lParam;
1657 time(&last_movement);
1658 return 0;
1659 case WM_SETFOCUS:
1660 has_focus = TRUE;
1661 CreateCaret(hwnd, caretbm, font_width, font_height);
1662 ShowCaret(hwnd);
1663 flash_window(0); /* stop */
1664 compose_state = 0;
1665 term_out();
1666 term_update();
1667 break;
1668 case WM_KILLFOCUS:
1669 show_mouseptr(1);
1670 has_focus = FALSE;
1671 DestroyCaret();
1672 term_out();
1673 term_update();
1674 break;
1675 case WM_IGNORE_SIZE:
1676 ignore_size = TRUE; /* don't panic on next WM_SIZE msg */
1677 break;
1678 case WM_ENTERSIZEMOVE:
1679 EnableSizeTip(1);
1680 resizing = TRUE;
1681 need_backend_resize = FALSE;
1682 break;
1683 case WM_EXITSIZEMOVE:
1684 EnableSizeTip(0);
1685 resizing = FALSE;
1686 if (need_backend_resize)
1687 back->size();
1688 break;
1689 case WM_SIZING:
1690 {
1691 int width, height, w, h, ew, eh;
1692 LPRECT r = (LPRECT) lParam;
1693
1694 width = r->right - r->left - extra_width;
1695 height = r->bottom - r->top - extra_height;
1696 w = (width + font_width / 2) / font_width;
1697 if (w < 1)
1698 w = 1;
1699 h = (height + font_height / 2) / font_height;
1700 if (h < 1)
1701 h = 1;
1702 UpdateSizeTip(hwnd, w, h);
1703 ew = width - w * font_width;
1704 eh = height - h * font_height;
1705 if (ew != 0) {
1706 if (wParam == WMSZ_LEFT ||
1707 wParam == WMSZ_BOTTOMLEFT || wParam == WMSZ_TOPLEFT)
1708 r->left += ew;
1709 else
1710 r->right -= ew;
1711 }
1712 if (eh != 0) {
1713 if (wParam == WMSZ_TOP ||
1714 wParam == WMSZ_TOPRIGHT || wParam == WMSZ_TOPLEFT)
1715 r->top += eh;
1716 else
1717 r->bottom -= eh;
1718 }
1719 if (ew || eh)
1720 return 1;
1721 else
1722 return 0;
1723 }
1724 /* break; (never reached) */
1725 case WM_SIZE:
1726 if (wParam == SIZE_MINIMIZED) {
1727 SetWindowText(hwnd,
1728 cfg.win_name_always ? window_name : icon_name);
1729 break;
1730 }
1731 if (wParam == SIZE_RESTORED || wParam == SIZE_MAXIMIZED)
1732 SetWindowText(hwnd, window_name);
1733 if (!ignore_size) {
1734 int width, height, w, h;
1735 #if 0 /* we have fixed this using WM_SIZING now */
1736 int ew, eh;
1737 #endif
1738
1739 width = LOWORD(lParam);
1740 height = HIWORD(lParam);
1741 w = width / font_width;
1742 if (w < 1)
1743 w = 1;
1744 h = height / font_height;
1745 if (h < 1)
1746 h = 1;
1747 #if 0 /* we have fixed this using WM_SIZING now */
1748 ew = width - w * font_width;
1749 eh = height - h * font_height;
1750 if (ew != 0 || eh != 0) {
1751 RECT r;
1752 GetWindowRect(hwnd, &r);
1753 SendMessage(hwnd, WM_IGNORE_SIZE, 0, 0);
1754 SetWindowPos(hwnd, NULL, 0, 0,
1755 r.right - r.left - ew, r.bottom - r.top - eh,
1756 SWP_NOACTIVATE | SWP_NOMOVE | SWP_NOZORDER);
1757 }
1758 #endif
1759 if (w != cols || h != rows || just_reconfigged) {
1760 term_invalidate();
1761 term_size(h, w, cfg.savelines);
1762 /*
1763 * Don't call back->size in mid-resize. (To prevent
1764 * massive numbers of resize events getting sent
1765 * down the connection during an NT opaque drag.)
1766 */
1767 if (!resizing)
1768 back->size();
1769 else {
1770 need_backend_resize = TRUE;
1771 cfg.height = h;
1772 cfg.width = w;
1773 }
1774 just_reconfigged = FALSE;
1775 }
1776 }
1777 if (wParam == SIZE_RESTORED && defered_resize) {
1778 defered_resize = FALSE;
1779 SetWindowPos(hwnd, NULL, 0, 0,
1780 extra_width + font_width * cfg.width,
1781 extra_height + font_height * cfg.height,
1782 SWP_NOACTIVATE | SWP_NOCOPYBITS |
1783 SWP_NOMOVE | SWP_NOZORDER);
1784 }
1785 ignore_size = FALSE;
1786 return 0;
1787 case WM_VSCROLL:
1788 switch (LOWORD(wParam)) {
1789 case SB_BOTTOM:
1790 term_scroll(-1, 0);
1791 break;
1792 case SB_TOP:
1793 term_scroll(+1, 0);
1794 break;
1795 case SB_LINEDOWN:
1796 term_scroll(0, +1);
1797 break;
1798 case SB_LINEUP:
1799 term_scroll(0, -1);
1800 break;
1801 case SB_PAGEDOWN:
1802 term_scroll(0, +rows / 2);
1803 break;
1804 case SB_PAGEUP:
1805 term_scroll(0, -rows / 2);
1806 break;
1807 case SB_THUMBPOSITION:
1808 case SB_THUMBTRACK:
1809 term_scroll(1, HIWORD(wParam));
1810 break;
1811 }
1812 break;
1813 case WM_PALETTECHANGED:
1814 if ((HWND) wParam != hwnd && pal != NULL) {
1815 HDC hdc = get_ctx();
1816 if (hdc) {
1817 if (RealizePalette(hdc) > 0)
1818 UpdateColors(hdc);
1819 free_ctx(hdc);
1820 }
1821 }
1822 break;
1823 case WM_QUERYNEWPALETTE:
1824 if (pal != NULL) {
1825 HDC hdc = get_ctx();
1826 if (hdc) {
1827 if (RealizePalette(hdc) > 0)
1828 UpdateColors(hdc);
1829 free_ctx(hdc);
1830 return TRUE;
1831 }
1832 }
1833 return FALSE;
1834 case WM_KEYDOWN:
1835 case WM_SYSKEYDOWN:
1836 case WM_KEYUP:
1837 case WM_SYSKEYUP:
1838 /*
1839 * Add the scan code and keypress timing to the random
1840 * number noise.
1841 */
1842 noise_ultralight(lParam);
1843
1844 /*
1845 * We don't do TranslateMessage since it disassociates the
1846 * resulting CHAR message from the KEYDOWN that sparked it,
1847 * which we occasionally don't want. Instead, we process
1848 * KEYDOWN, and call the Win32 translator functions so that
1849 * we get the translations under _our_ control.
1850 */
1851 {
1852 unsigned char buf[20];
1853 int len;
1854
1855 if (wParam == VK_PROCESSKEY) {
1856 MSG m;
1857 m.hwnd = hwnd;
1858 m.message = WM_KEYDOWN;
1859 m.wParam = wParam;
1860 m.lParam = lParam & 0xdfff;
1861 TranslateMessage(&m);
1862 } else {
1863 len = TranslateKey(message, wParam, lParam, buf);
1864 if (len == -1)
1865 return DefWindowProc(hwnd, message, wParam, lParam);
1866
1867 /*
1868 * We need not bother about stdin backlogs here,
1869 * because in GUI PuTTY we can't do anything about
1870 * it anyway; there's no means of asking Windows to
1871 * hold off on KEYDOWN messages. We _have_ to
1872 * buffer everything we're sent.
1873 */
1874 ldisc_send(buf, len);
1875
1876 if (len > 0)
1877 show_mouseptr(0);
1878 }
1879 }
1880 return 0;
1881 case WM_INPUTLANGCHANGE:
1882 {
1883 /* wParam == Font number */
1884 /* lParam == Locale */
1885 char lbuf[20];
1886 HKL NewInputLocale = (HKL) lParam;
1887
1888 // lParam == GetKeyboardLayout(0);
1889
1890 GetLocaleInfo(LOWORD(NewInputLocale),
1891 LOCALE_IDEFAULTANSICODEPAGE, lbuf, sizeof(lbuf));
1892
1893 kbd_codepage = atoi(lbuf);
1894 }
1895 break;
1896 case WM_IME_COMPOSITION:
1897 {
1898 HIMC hIMC;
1899 int n;
1900 char *buff;
1901
1902 if(osVersion.dwPlatformId == VER_PLATFORM_WIN32_WINDOWS ||
1903 osVersion.dwPlatformId == VER_PLATFORM_WIN32s) break; /* no Unicode */
1904
1905 if ((lParam & GCS_RESULTSTR) == 0) /* Composition unfinished. */
1906 break; /* fall back to DefWindowProc */
1907
1908 hIMC = ImmGetContext(hwnd);
1909 n = ImmGetCompositionStringW(hIMC, GCS_RESULTSTR, NULL, 0);
1910
1911 if (n > 0) {
1912 buff = (char*) smalloc(n);
1913 ImmGetCompositionStringW(hIMC, GCS_RESULTSTR, buff, n);
1914 luni_send((unsigned short *)buff, n / 2);
1915 free(buff);
1916 }
1917 ImmReleaseContext(hwnd, hIMC);
1918 return 1;
1919 }
1920
1921 case WM_IME_CHAR:
1922 if (wParam & 0xFF00) {
1923 unsigned char buf[2];
1924
1925 buf[1] = wParam;
1926 buf[0] = wParam >> 8;
1927 lpage_send(kbd_codepage, buf, 2);
1928 } else {
1929 char c = (unsigned char) wParam;
1930 lpage_send(kbd_codepage, &c, 1);
1931 }
1932 return (0);
1933 case WM_CHAR:
1934 case WM_SYSCHAR:
1935 /*
1936 * Nevertheless, we are prepared to deal with WM_CHAR
1937 * messages, should they crop up. So if someone wants to
1938 * post the things to us as part of a macro manoeuvre,
1939 * we're ready to cope.
1940 */
1941 {
1942 char c = (unsigned char)wParam;
1943 lpage_send(CP_ACP, &c, 1);
1944 }
1945 return 0;
1946 case WM_SETCURSOR:
1947 if (send_raw_mouse) {
1948 SetCursor(LoadCursor(NULL, IDC_ARROW));
1949 return TRUE;
1950 }
1951 }
1952
1953 return DefWindowProc(hwnd, message, wParam, lParam);
1954 }
1955
1956 /*
1957 * Move the system caret. (We maintain one, even though it's
1958 * invisible, for the benefit of blind people: apparently some
1959 * helper software tracks the system caret, so we should arrange to
1960 * have one.)
1961 */
1962 void sys_cursor(int x, int y)
1963 {
1964 COMPOSITIONFORM cf;
1965 HIMC hIMC;
1966
1967 if (!has_focus) return;
1968
1969 SetCaretPos(x * font_width, y * font_height);
1970
1971 /* IMM calls on Win98 and beyond only */
1972 if(osVersion.dwPlatformId == VER_PLATFORM_WIN32s) return; /* 3.11 */
1973
1974 if(osVersion.dwPlatformId == VER_PLATFORM_WIN32_WINDOWS &&
1975 osVersion.dwMinorVersion == 0) return; /* 95 */
1976
1977 /* we should have the IMM functions */
1978 hIMC = ImmGetContext(hwnd);
1979 cf.dwStyle = CFS_POINT;
1980 cf.ptCurrentPos.x = x * font_width;
1981 cf.ptCurrentPos.y = y * font_height;
1982 ImmSetCompositionWindow(hIMC, &cf);
1983
1984 ImmReleaseContext(hwnd, hIMC);
1985 }
1986
1987 /*
1988 * Draw a line of text in the window, at given character
1989 * coordinates, in given attributes.
1990 *
1991 * We are allowed to fiddle with the contents of `text'.
1992 */
1993 void do_text(Context ctx, int x, int y, char *text, int len,
1994 unsigned long attr, int lattr)
1995 {
1996 COLORREF fg, bg, t;
1997 int nfg, nbg, nfont;
1998 HDC hdc = ctx;
1999 RECT line_box;
2000 int force_manual_underline = 0;
2001 int fnt_width = font_width * (1 + (lattr != LATTR_NORM));
2002 int char_width = fnt_width;
2003 int text_adjust = 0;
2004 static int *IpDx = 0, IpDxLEN = 0;
2005
2006 if (attr & ATTR_WIDE)
2007 char_width *= 2;
2008
2009 if (len > IpDxLEN || IpDx[0] != char_width) {
2010 int i;
2011 if (len > IpDxLEN) {
2012 sfree(IpDx);
2013 IpDx = smalloc((len + 16) * sizeof(int));
2014 IpDxLEN = (len + 16);
2015 }
2016 for (i = 0; i < IpDxLEN; i++)
2017 IpDx[i] = char_width;
2018 }
2019
2020 x *= fnt_width;
2021 y *= font_height;
2022
2023 if ((attr & TATTR_ACTCURS) && (cfg.cursor_type == 0 || big_cursor)) {
2024 attr &= ATTR_CUR_AND | (bold_mode != BOLD_COLOURS ? ATTR_BOLD : 0);
2025 attr ^= ATTR_CUR_XOR;
2026 }
2027
2028 nfont = 0;
2029 if (cfg.vtmode == VT_POORMAN && lattr != LATTR_NORM) {
2030 /* Assume a poorman font is borken in other ways too. */
2031 lattr = LATTR_WIDE;
2032 } else
2033 switch (lattr) {
2034 case LATTR_NORM:
2035 break;
2036 case LATTR_WIDE:
2037 nfont |= FONT_WIDE;
2038 break;
2039 default:
2040 nfont |= FONT_WIDE + FONT_HIGH;
2041 break;
2042 }
2043
2044 /* Special hack for the VT100 linedraw glyphs. */
2045 if ((attr & CSET_MASK) == 0x2300) {
2046 if (!dbcs_screenfont &&
2047 text[0] >= (char) 0xBA && text[0] <= (char) 0xBD) {
2048 switch ((unsigned char) (text[0])) {
2049 case 0xBA:
2050 text_adjust = -2 * font_height / 5;
2051 break;
2052 case 0xBB:
2053 text_adjust = -1 * font_height / 5;
2054 break;
2055 case 0xBC:
2056 text_adjust = font_height / 5;
2057 break;
2058 case 0xBD:
2059 text_adjust = 2 * font_height / 5;
2060 break;
2061 }
2062 if (lattr == LATTR_TOP || lattr == LATTR_BOT)
2063 text_adjust *= 2;
2064 attr &= ~CSET_MASK;
2065 text[0] = (char) (unitab_xterm['q'] & CHAR_MASK);
2066 attr |= (unitab_xterm['q'] & CSET_MASK);
2067 if (attr & ATTR_UNDER) {
2068 attr &= ~ATTR_UNDER;
2069 force_manual_underline = 1;
2070 }
2071 }
2072 }
2073
2074 /* Anything left as an original character set is unprintable. */
2075 if (DIRECT_CHAR(attr)) {
2076 attr &= ~CSET_MASK;
2077 attr |= 0xFF00;
2078 memset(text, 0xFF, len);
2079 }
2080
2081 /* OEM CP */
2082 if ((attr & CSET_MASK) == ATTR_OEMCP)
2083 nfont |= FONT_OEM;
2084
2085 nfg = 2 * ((attr & ATTR_FGMASK) >> ATTR_FGSHIFT);
2086 nbg = 2 * ((attr & ATTR_BGMASK) >> ATTR_BGSHIFT);
2087 if (bold_mode == BOLD_FONT && (attr & ATTR_BOLD))
2088 nfont |= FONT_BOLD;
2089 if (und_mode == UND_FONT && (attr & ATTR_UNDER))
2090 nfont |= FONT_UNDERLINE;
2091 another_font(nfont);
2092 if (!fonts[nfont]) {
2093 if (nfont & FONT_UNDERLINE)
2094 force_manual_underline = 1;
2095 /* Don't do the same for manual bold, it could be bad news. */
2096
2097 nfont &= ~(FONT_BOLD | FONT_UNDERLINE);
2098 }
2099 another_font(nfont);
2100 if (!fonts[nfont])
2101 nfont = FONT_NORMAL;
2102 if (attr & ATTR_REVERSE) {
2103 t = nfg;
2104 nfg = nbg;
2105 nbg = t;
2106 }
2107 if (bold_mode == BOLD_COLOURS && (attr & ATTR_BOLD))
2108 nfg++;
2109 if (bold_mode == BOLD_COLOURS && (attr & ATTR_BLINK))
2110 nbg++;
2111 fg = colours[nfg];
2112 bg = colours[nbg];
2113 SelectObject(hdc, fonts[nfont]);
2114 SetTextColor(hdc, fg);
2115 SetBkColor(hdc, bg);
2116 SetBkMode(hdc, OPAQUE);
2117 line_box.left = x;
2118 line_box.top = y;
2119 line_box.right = x + char_width * len;
2120 line_box.bottom = y + font_height;
2121
2122 /* We're using a private area for direct to font. (512 chars.) */
2123 if (dbcs_screenfont && (attr & CSET_MASK) == ATTR_ACP) {
2124 /* Ho Hum, dbcs fonts are a PITA! */
2125 /* To display on W9x I have to convert to UCS */
2126 static wchar_t *uni_buf = 0;
2127 static int uni_len = 0;
2128 int nlen;
2129 if (len > uni_len) {
2130 sfree(uni_buf);
2131 uni_buf = smalloc((uni_len = len) * sizeof(wchar_t));
2132 }
2133 nlen = MultiByteToWideChar(font_codepage, MB_USEGLYPHCHARS,
2134 text, len, uni_buf, uni_len);
2135
2136 if (nlen <= 0)
2137 return; /* Eeek! */
2138
2139 ExtTextOutW(hdc, x,
2140 y - font_height * (lattr == LATTR_BOT) + text_adjust,
2141 ETO_CLIPPED | ETO_OPAQUE, &line_box, uni_buf, nlen, 0);
2142 if (bold_mode == BOLD_SHADOW && (attr & ATTR_BOLD)) {
2143 SetBkMode(hdc, TRANSPARENT);
2144 ExtTextOutW(hdc, x - 1,
2145 y - font_height * (lattr ==
2146 LATTR_BOT) + text_adjust,
2147 ETO_CLIPPED, &line_box, uni_buf, nlen, 0);
2148 }
2149 } else if (DIRECT_FONT(attr)) {
2150 ExtTextOut(hdc, x,
2151 y - font_height * (lattr == LATTR_BOT) + text_adjust,
2152 ETO_CLIPPED | ETO_OPAQUE, &line_box, text, len, IpDx);
2153 if (bold_mode == BOLD_SHADOW && (attr & ATTR_BOLD)) {
2154 SetBkMode(hdc, TRANSPARENT);
2155
2156 /* GRR: This draws the character outside it's box and can leave
2157 * 'droppings' even with the clip box! I suppose I could loop it
2158 * one character at a time ... yuk.
2159 *
2160 * Or ... I could do a test print with "W", and use +1 or -1 for this
2161 * shift depending on if the leftmost column is blank...
2162 */
2163 ExtTextOut(hdc, x - 1,
2164 y - font_height * (lattr ==
2165 LATTR_BOT) + text_adjust,
2166 ETO_CLIPPED, &line_box, text, len, IpDx);
2167 }
2168 } else {
2169 /* And 'normal' unicode characters */
2170 static WCHAR *wbuf = NULL;
2171 static int wlen = 0;
2172 int i;
2173 if (wlen < len) {
2174 sfree(wbuf);
2175 wlen = len;
2176 wbuf = smalloc(wlen * sizeof(WCHAR));
2177 }
2178 for (i = 0; i < len; i++)
2179 wbuf[i] = (WCHAR) ((attr & CSET_MASK) + (text[i] & CHAR_MASK));
2180
2181 ExtTextOutW(hdc, x,
2182 y - font_height * (lattr == LATTR_BOT) + text_adjust,
2183 ETO_CLIPPED | ETO_OPAQUE, &line_box, wbuf, len, IpDx);
2184
2185 /* And the shadow bold hack. */
2186 if (bold_mode == BOLD_SHADOW) {
2187 SetBkMode(hdc, TRANSPARENT);
2188 ExtTextOutW(hdc, x - 1,
2189 y - font_height * (lattr ==
2190 LATTR_BOT) + text_adjust,
2191 ETO_CLIPPED, &line_box, wbuf, len, IpDx);
2192 }
2193 }
2194 if (lattr != LATTR_TOP && (force_manual_underline ||
2195 (und_mode == UND_LINE
2196 && (attr & ATTR_UNDER)))) {
2197 HPEN oldpen;
2198 int dec = descent;
2199 if (lattr == LATTR_BOT)
2200 dec = dec * 2 - font_height;
2201
2202 oldpen = SelectObject(hdc, CreatePen(PS_SOLID, 0, fg));
2203 MoveToEx(hdc, x, y + dec, NULL);
2204 LineTo(hdc, x + len * char_width, y + dec);
2205 oldpen = SelectObject(hdc, oldpen);
2206 DeleteObject(oldpen);
2207 }
2208 }
2209
2210 void do_cursor(Context ctx, int x, int y, char *text, int len,
2211 unsigned long attr, int lattr)
2212 {
2213
2214 int fnt_width;
2215 int char_width;
2216 HDC hdc = ctx;
2217 int ctype = cfg.cursor_type;
2218
2219 if ((attr & TATTR_ACTCURS) && (ctype == 0 || big_cursor)) {
2220 if (((attr & CSET_MASK) | (unsigned char) *text) != UCSWIDE) {
2221 do_text(ctx, x, y, text, len, attr, lattr);
2222 return;
2223 }
2224 ctype = 2;
2225 attr |= TATTR_RIGHTCURS;
2226 }
2227
2228 fnt_width = char_width = font_width * (1 + (lattr != LATTR_NORM));
2229 if (attr & ATTR_WIDE)
2230 char_width *= 2;
2231 x *= fnt_width;
2232 y *= font_height;
2233
2234 if ((attr & TATTR_PASCURS) && (ctype == 0 || big_cursor)) {
2235 POINT pts[5];
2236 HPEN oldpen;
2237 pts[0].x = pts[1].x = pts[4].x = x;
2238 pts[2].x = pts[3].x = x + char_width - 1;
2239 pts[0].y = pts[3].y = pts[4].y = y;
2240 pts[1].y = pts[2].y = y + font_height - 1;
2241 oldpen = SelectObject(hdc, CreatePen(PS_SOLID, 0, colours[23]));
2242 Polyline(hdc, pts, 5);
2243 oldpen = SelectObject(hdc, oldpen);
2244 DeleteObject(oldpen);
2245 } else if ((attr & (TATTR_ACTCURS | TATTR_PASCURS)) && ctype != 0) {
2246 int startx, starty, dx, dy, length, i;
2247 if (ctype == 1) {
2248 startx = x;
2249 starty = y + descent;
2250 dx = 1;
2251 dy = 0;
2252 length = char_width;
2253 } else {
2254 int xadjust = 0;
2255 if (attr & TATTR_RIGHTCURS)
2256 xadjust = char_width - 1;
2257 startx = x + xadjust;
2258 starty = y;
2259 dx = 0;
2260 dy = 1;
2261 length = font_height;
2262 }
2263 if (attr & TATTR_ACTCURS) {
2264 HPEN oldpen;
2265 oldpen =
2266 SelectObject(hdc, CreatePen(PS_SOLID, 0, colours[23]));
2267 MoveToEx(hdc, startx, starty, NULL);
2268 LineTo(hdc, startx + dx * length, starty + dy * length);
2269 oldpen = SelectObject(hdc, oldpen);
2270 DeleteObject(oldpen);
2271 } else {
2272 for (i = 0; i < length; i++) {
2273 if (i % 2 == 0) {
2274 SetPixel(hdc, startx, starty, colours[23]);
2275 }
2276 startx += dx;
2277 starty += dy;
2278 }
2279 }
2280 }
2281 }
2282
2283 /*
2284 * Translate a WM_(SYS)?KEY(UP|DOWN) message into a string of ASCII
2285 * codes. Returns number of bytes used or zero to drop the message
2286 * or -1 to forward the message to windows.
2287 */
2288 static int TranslateKey(UINT message, WPARAM wParam, LPARAM lParam,
2289 unsigned char *output)
2290 {
2291 BYTE keystate[256];
2292 int scan, left_alt = 0, key_down, shift_state;
2293 int r, i, code;
2294 unsigned char *p = output;
2295 static int alt_state = 0;
2296 static int alt_sum = 0;
2297
2298 HKL kbd_layout = GetKeyboardLayout(0);
2299
2300 static WORD keys[3];
2301 static int compose_char = 0;
2302 static WPARAM compose_key = 0;
2303
2304 r = GetKeyboardState(keystate);
2305 if (!r)
2306 memset(keystate, 0, sizeof(keystate));
2307 else {
2308 #if 0
2309 #define SHOW_TOASCII_RESULT
2310 { /* Tell us all about key events */
2311 static BYTE oldstate[256];
2312 static int first = 1;
2313 static int scan;
2314 int ch;
2315 if (first)
2316 memcpy(oldstate, keystate, sizeof(oldstate));
2317 first = 0;
2318
2319 if ((HIWORD(lParam) & (KF_UP | KF_REPEAT)) == KF_REPEAT) {
2320 debug(("+"));
2321 } else if ((HIWORD(lParam) & KF_UP)
2322 && scan == (HIWORD(lParam) & 0xFF)) {
2323 debug((". U"));
2324 } else {
2325 debug((".\n"));
2326 if (wParam >= VK_F1 && wParam <= VK_F20)
2327 debug(("K_F%d", wParam + 1 - VK_F1));
2328 else
2329 switch (wParam) {
2330 case VK_SHIFT:
2331 debug(("SHIFT"));
2332 break;
2333 case VK_CONTROL:
2334 debug(("CTRL"));
2335 break;
2336 case VK_MENU:
2337 debug(("ALT"));
2338 break;
2339 default:
2340 debug(("VK_%02x", wParam));
2341 }
2342 if (message == WM_SYSKEYDOWN || message == WM_SYSKEYUP)
2343 debug(("*"));
2344 debug((", S%02x", scan = (HIWORD(lParam) & 0xFF)));
2345
2346 ch = MapVirtualKeyEx(wParam, 2, kbd_layout);
2347 if (ch >= ' ' && ch <= '~')
2348 debug((", '%c'", ch));
2349 else if (ch)
2350 debug((", $%02x", ch));
2351
2352 if (keys[0])
2353 debug((", KB0=%02x", keys[0]));
2354 if (keys[1])
2355 debug((", KB1=%02x", keys[1]));
2356 if (keys[2])
2357 debug((", KB2=%02x", keys[2]));
2358
2359 if ((keystate[VK_SHIFT] & 0x80) != 0)
2360 debug((", S"));
2361 if ((keystate[VK_CONTROL] & 0x80) != 0)
2362 debug((", C"));
2363 if ((HIWORD(lParam) & KF_EXTENDED))
2364 debug((", E"));
2365 if ((HIWORD(lParam) & KF_UP))
2366 debug((", U"));
2367 }
2368
2369 if ((HIWORD(lParam) & (KF_UP | KF_REPEAT)) == KF_REPEAT);
2370 else if ((HIWORD(lParam) & KF_UP))
2371 oldstate[wParam & 0xFF] ^= 0x80;
2372 else
2373 oldstate[wParam & 0xFF] ^= 0x81;
2374
2375 for (ch = 0; ch < 256; ch++)
2376 if (oldstate[ch] != keystate[ch])
2377 debug((", M%02x=%02x", ch, keystate[ch]));
2378
2379 memcpy(oldstate, keystate, sizeof(oldstate));
2380 }
2381 #endif
2382
2383 if (wParam == VK_MENU && (HIWORD(lParam) & KF_EXTENDED)) {
2384 keystate[VK_RMENU] = keystate[VK_MENU];
2385 }
2386
2387
2388 /* Nastyness with NUMLock - Shift-NUMLock is left alone though */
2389 if ((cfg.funky_type == 3 ||
2390 (cfg.funky_type <= 1 && app_keypad_keys && !cfg.no_applic_k))
2391 && wParam == VK_NUMLOCK && !(keystate[VK_SHIFT] & 0x80)) {
2392
2393 wParam = VK_EXECUTE;
2394
2395 /* UnToggle NUMLock */
2396 if ((HIWORD(lParam) & (KF_UP | KF_REPEAT)) == 0)
2397 keystate[VK_NUMLOCK] ^= 1;
2398 }
2399
2400 /* And write back the 'adjusted' state */
2401 SetKeyboardState(keystate);
2402 }
2403
2404 /* Disable Auto repeat if required */
2405 if (repeat_off && (HIWORD(lParam) & (KF_UP | KF_REPEAT)) == KF_REPEAT)
2406 return 0;
2407
2408 if ((HIWORD(lParam) & KF_ALTDOWN) && (keystate[VK_RMENU] & 0x80) == 0)
2409 left_alt = 1;
2410
2411 key_down = ((HIWORD(lParam) & KF_UP) == 0);
2412
2413 /* Make sure Ctrl-ALT is not the same as AltGr for ToAscii unless told. */
2414 if (left_alt && (keystate[VK_CONTROL] & 0x80)) {
2415 if (cfg.ctrlaltkeys)
2416 keystate[VK_MENU] = 0;
2417 else {
2418 keystate[VK_RMENU] = 0x80;
2419 left_alt = 0;
2420 }
2421 }
2422
2423 scan = (HIWORD(lParam) & (KF_UP | KF_EXTENDED | 0xFF));
2424 shift_state = ((keystate[VK_SHIFT] & 0x80) != 0)
2425 + ((keystate[VK_CONTROL] & 0x80) != 0) * 2;
2426
2427 /* Note if AltGr was pressed and if it was used as a compose key */
2428 if (!compose_state) {
2429 compose_key = 0x100;
2430 if (cfg.compose_key) {
2431 if (wParam == VK_MENU && (HIWORD(lParam) & KF_EXTENDED))
2432 compose_key = wParam;
2433 }
2434 if (wParam == VK_APPS)
2435 compose_key = wParam;
2436 }
2437
2438 if (wParam == compose_key) {
2439 if (compose_state == 0
2440 && (HIWORD(lParam) & (KF_UP | KF_REPEAT)) == 0) compose_state =
2441 1;
2442 else if (compose_state == 1 && (HIWORD(lParam) & KF_UP))
2443 compose_state = 2;
2444 else
2445 compose_state = 0;
2446 } else if (compose_state == 1 && wParam != VK_CONTROL)
2447 compose_state = 0;
2448
2449 /*
2450 * Record that we pressed key so the scroll window can be reset, but
2451 * be careful to avoid Shift-UP/Down
2452 */
2453 if (wParam != VK_SHIFT && wParam != VK_PRIOR && wParam != VK_NEXT) {
2454 seen_key_event = 1;
2455 }
2456
2457 /* Make sure we're not pasting */
2458 if (key_down)
2459 term_nopaste();
2460
2461 if (compose_state > 1 && left_alt)
2462 compose_state = 0;
2463
2464 /* Sanitize the number pad if not using a PC NumPad */
2465 if (left_alt || (app_keypad_keys && !cfg.no_applic_k
2466 && cfg.funky_type != 2)
2467 || cfg.funky_type == 3 || cfg.nethack_keypad || compose_state) {
2468 if ((HIWORD(lParam) & KF_EXTENDED) == 0) {
2469 int nParam = 0;
2470 switch (wParam) {
2471 case VK_INSERT:
2472 nParam = VK_NUMPAD0;
2473 break;
2474 case VK_END:
2475 nParam = VK_NUMPAD1;
2476 break;
2477 case VK_DOWN:
2478 nParam = VK_NUMPAD2;
2479 break;
2480 case VK_NEXT:
2481 nParam = VK_NUMPAD3;
2482 break;
2483 case VK_LEFT:
2484 nParam = VK_NUMPAD4;
2485 break;
2486 case VK_CLEAR:
2487 nParam = VK_NUMPAD5;
2488 break;
2489 case VK_RIGHT:
2490 nParam = VK_NUMPAD6;
2491 break;
2492 case VK_HOME:
2493 nParam = VK_NUMPAD7;
2494 break;
2495 case VK_UP:
2496 nParam = VK_NUMPAD8;
2497 break;
2498 case VK_PRIOR:
2499 nParam = VK_NUMPAD9;
2500 break;
2501 case VK_DELETE:
2502 nParam = VK_DECIMAL;
2503 break;
2504 }
2505 if (nParam) {
2506 if (keystate[VK_NUMLOCK] & 1)
2507 shift_state |= 1;
2508 wParam = nParam;
2509 }
2510 }
2511 }
2512
2513 /* If a key is pressed and AltGr is not active */
2514 if (key_down && (keystate[VK_RMENU] & 0x80) == 0 && !compose_state) {
2515 /* Okay, prepare for most alts then ... */
2516 if (left_alt)
2517 *p++ = '\033';
2518
2519 /* Lets see if it's a pattern we know all about ... */
2520 if (wParam == VK_PRIOR && shift_state == 1) {
2521 SendMessage(hwnd, WM_VSCROLL, SB_PAGEUP, 0);
2522 return 0;
2523 }
2524 if (wParam == VK_NEXT && shift_state == 1) {
2525 SendMessage(hwnd, WM_VSCROLL, SB_PAGEDOWN, 0);
2526 return 0;
2527 }
2528 if (wParam == VK_INSERT && shift_state == 1) {
2529 term_do_paste();
2530 return 0;
2531 }
2532 if (left_alt && wParam == VK_F4 && cfg.alt_f4) {
2533 return -1;
2534 }
2535 if (left_alt && wParam == VK_SPACE && cfg.alt_space) {
2536 alt_state = 0;
2537 PostMessage(hwnd, WM_CHAR, ' ', 0);
2538 SendMessage(hwnd, WM_SYSCOMMAND, SC_KEYMENU, 0);
2539 return -1;
2540 }
2541 /* Control-Numlock for app-keypad mode switch */
2542 if (wParam == VK_PAUSE && shift_state == 2) {
2543 app_keypad_keys ^= 1;
2544 return 0;
2545 }
2546
2547 /* Nethack keypad */
2548 if (cfg.nethack_keypad && !left_alt) {
2549 switch (wParam) {
2550 case VK_NUMPAD1:
2551 *p++ = shift_state ? 'B' : 'b';
2552 return p - output;
2553 case VK_NUMPAD2:
2554 *p++ = shift_state ? 'J' : 'j';
2555 return p - output;
2556 case VK_NUMPAD3:
2557 *p++ = shift_state ? 'N' : 'n';
2558 return p - output;
2559 case VK_NUMPAD4:
2560 *p++ = shift_state ? 'H' : 'h';
2561 return p - output;
2562 case VK_NUMPAD5:
2563 *p++ = shift_state ? '.' : '.';
2564 return p - output;
2565 case VK_NUMPAD6:
2566 *p++ = shift_state ? 'L' : 'l';
2567 return p - output;
2568 case VK_NUMPAD7:
2569 *p++ = shift_state ? 'Y' : 'y';
2570 return p - output;
2571 case VK_NUMPAD8:
2572 *p++ = shift_state ? 'K' : 'k';
2573 return p - output;
2574 case VK_NUMPAD9:
2575 *p++ = shift_state ? 'U' : 'u';
2576 return p - output;
2577 }
2578 }
2579
2580 /* Application Keypad */
2581 if (!left_alt) {
2582 int xkey = 0;
2583
2584 if (cfg.funky_type == 3 ||
2585 (cfg.funky_type <= 1 &&
2586 app_keypad_keys && !cfg.no_applic_k)) switch (wParam) {
2587 case VK_EXECUTE:
2588 xkey = 'P';
2589 break;
2590 case VK_DIVIDE:
2591 xkey = 'Q';
2592 break;
2593 case VK_MULTIPLY:
2594 xkey = 'R';
2595 break;
2596 case VK_SUBTRACT:
2597 xkey = 'S';
2598 break;
2599 }
2600 if (app_keypad_keys && !cfg.no_applic_k)
2601 switch (wParam) {
2602 case VK_NUMPAD0:
2603 xkey = 'p';
2604 break;
2605 case VK_NUMPAD1:
2606 xkey = 'q';
2607 break;
2608 case VK_NUMPAD2:
2609 xkey = 'r';
2610 break;
2611 case VK_NUMPAD3:
2612 xkey = 's';
2613 break;
2614 case VK_NUMPAD4:
2615 xkey = 't';
2616 break;
2617 case VK_NUMPAD5:
2618 xkey = 'u';
2619 break;
2620 case VK_NUMPAD6:
2621 xkey = 'v';
2622 break;
2623 case VK_NUMPAD7:
2624 xkey = 'w';
2625 break;
2626 case VK_NUMPAD8:
2627 xkey = 'x';
2628 break;
2629 case VK_NUMPAD9:
2630 xkey = 'y';
2631 break;
2632
2633 case VK_DECIMAL:
2634 xkey = 'n';
2635 break;
2636 case VK_ADD:
2637 if (cfg.funky_type == 2) {
2638 if (shift_state)
2639 xkey = 'l';
2640 else
2641 xkey = 'k';
2642 } else if (shift_state)
2643 xkey = 'm';
2644 else
2645 xkey = 'l';
2646 break;
2647
2648 case VK_DIVIDE:
2649 if (cfg.funky_type == 2)
2650 xkey = 'o';
2651 break;
2652 case VK_MULTIPLY:
2653 if (cfg.funky_type == 2)
2654 xkey = 'j';
2655 break;
2656 case VK_SUBTRACT:
2657 if (cfg.funky_type == 2)
2658 xkey = 'm';
2659 break;
2660
2661 case VK_RETURN:
2662 if (HIWORD(lParam) & KF_EXTENDED)
2663 xkey = 'M';
2664 break;
2665 }
2666 if (xkey) {
2667 if (vt52_mode) {
2668 if (xkey >= 'P' && xkey <= 'S')
2669 p += sprintf((char *) p, "\x1B%c", xkey);
2670 else
2671 p += sprintf((char *) p, "\x1B?%c", xkey);
2672 } else
2673 p += sprintf((char *) p, "\x1BO%c", xkey);
2674 return p - output;
2675 }
2676 }
2677
2678 if (wParam == VK_BACK && shift_state == 0) { /* Backspace */
2679 *p++ = (cfg.bksp_is_delete ? 0x7F : 0x08);
2680 *p++ = 0;
2681 return -2;
2682 }
2683 if (wParam == VK_TAB && shift_state == 1) { /* Shift tab */
2684 *p++ = 0x1B;
2685 *p++ = '[';
2686 *p++ = 'Z';
2687 return p - output;
2688 }
2689 if (wParam == VK_SPACE && shift_state == 2) { /* Ctrl-Space */
2690 *p++ = 0;
2691 return p - output;
2692 }
2693 if (wParam == VK_SPACE && shift_state == 3) { /* Ctrl-Shift-Space */
2694 *p++ = 160;
2695 return p - output;
2696 }
2697 if (wParam == VK_CANCEL && shift_state == 2) { /* Ctrl-Break */
2698 *p++ = 3;
2699 *p++ = 0;
2700 return -2;
2701 }
2702 if (wParam == VK_PAUSE) { /* Break/Pause */
2703 *p++ = 26;
2704 *p++ = 0;
2705 return -2;
2706 }
2707 /* Control-2 to Control-8 are special */
2708 if (shift_state == 2 && wParam >= '2' && wParam <= '8') {
2709 *p++ = "\000\033\034\035\036\037\177"[wParam - '2'];
2710 return p - output;
2711 }
2712 if (shift_state == 2 && wParam == 0xBD) {
2713 *p++ = 0x1F;
2714 return p - output;
2715 }
2716 if (shift_state == 2 && wParam == 0xDF) {
2717 *p++ = 0x1C;
2718 return p - output;
2719 }
2720 if (shift_state == 0 && wParam == VK_RETURN && cr_lf_return) {
2721 *p++ = '\r';
2722 *p++ = '\n';
2723 return p - output;
2724 }
2725
2726 /*
2727 * Next, all the keys that do tilde codes. (ESC '[' nn '~',
2728 * for integer decimal nn.)
2729 *
2730 * We also deal with the weird ones here. Linux VCs replace F1
2731 * to F5 by ESC [ [ A to ESC [ [ E. rxvt doesn't do _that_, but
2732 * does replace Home and End (1~ and 4~) by ESC [ H and ESC O w
2733 * respectively.
2734 */
2735 code = 0;
2736 switch (wParam) {
2737 case VK_F1:
2738 code = (keystate[VK_SHIFT] & 0x80 ? 23 : 11);
2739 break;
2740 case VK_F2:
2741 code = (keystate[VK_SHIFT] & 0x80 ? 24 : 12);
2742 break;
2743 case VK_F3:
2744 code = (keystate[VK_SHIFT] & 0x80 ? 25 : 13);
2745 break;
2746 case VK_F4:
2747 code = (keystate[VK_SHIFT] & 0x80 ? 26 : 14);
2748 break;
2749 case VK_F5:
2750 code = (keystate[VK_SHIFT] & 0x80 ? 28 : 15);
2751 break;
2752 case VK_F6:
2753 code = (keystate[VK_SHIFT] & 0x80 ? 29 : 17);
2754 break;
2755 case VK_F7:
2756 code = (keystate[VK_SHIFT] & 0x80 ? 31 : 18);
2757 break;
2758 case VK_F8:
2759 code = (keystate[VK_SHIFT] & 0x80 ? 32 : 19);
2760 break;
2761 case VK_F9:
2762 code = (keystate[VK_SHIFT] & 0x80 ? 33 : 20);
2763 break;
2764 case VK_F10:
2765 code = (keystate[VK_SHIFT] & 0x80 ? 34 : 21);
2766 break;
2767 case VK_F11:
2768 code = 23;
2769 break;
2770 case VK_F12:
2771 code = 24;
2772 break;
2773 case VK_F13:
2774 code = 25;
2775 break;
2776 case VK_F14:
2777 code = 26;
2778 break;
2779 case VK_F15:
2780 code = 28;
2781 break;
2782 case VK_F16:
2783 code = 29;
2784 break;
2785 case VK_F17:
2786 code = 31;
2787 break;
2788 case VK_F18:
2789 code = 32;
2790 break;
2791 case VK_F19:
2792 code = 33;
2793 break;
2794 case VK_F20:
2795 code = 34;
2796 break;
2797 case VK_HOME:
2798 code = 1;
2799 break;
2800 case VK_INSERT:
2801 code = 2;
2802 break;
2803 case VK_DELETE:
2804 code = 3;
2805 break;
2806 case VK_END:
2807 code = 4;
2808 break;
2809 case VK_PRIOR:
2810 code = 5;
2811 break;
2812 case VK_NEXT:
2813 code = 6;
2814 break;
2815 }
2816 /* Reorder edit keys to physical order */
2817 if (cfg.funky_type == 3 && code <= 6)
2818 code = "\0\2\1\4\5\3\6"[code];
2819
2820 if (vt52_mode && code > 0 && code <= 6) {
2821 p += sprintf((char *) p, "\x1B%c", " HLMEIG"[code]);
2822 return p - output;
2823 }
2824
2825 if (cfg.funky_type == 5 && /* SCO function keys */
2826 code >= 11 && code <= 34) {
2827 char codes[] = "MNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz@[\\]^_`{";
2828 int index = 0;
2829 switch (wParam) {
2830 case VK_F1: index = 0; break;
2831 case VK_F2: index = 1; break;
2832 case VK_F3: index = 2; break;
2833 case VK_F4: index = 3; break;
2834 case VK_F5: index = 4; break;
2835 case VK_F6: index = 5; break;
2836 case VK_F7: index = 6; break;
2837 case VK_F8: index = 7; break;
2838 case VK_F9: index = 8; break;
2839 case VK_F10: index = 9; break;
2840 case VK_F11: index = 10; break;
2841 case VK_F12: index = 11; break;
2842 }
2843 if (keystate[VK_SHIFT] & 0x80) index += 12;
2844 if (keystate[VK_CONTROL] & 0x80) index += 24;
2845 p += sprintf((char *) p, "\x1B[%c", codes[index]);
2846 return p - output;
2847 }
2848 if (cfg.funky_type == 5 && /* SCO small keypad */
2849 code >= 1 && code <= 6) {
2850 char codes[] = "HL.FIG";
2851 if (code == 3) {
2852 *p++ = '\x7F';
2853 } else {
2854 p += sprintf((char *) p, "\x1B[%c", codes[code-1]);
2855 }
2856 return p - output;
2857 }
2858 if ((vt52_mode || cfg.funky_type == 4) && code >= 11 && code <= 24) {
2859 int offt = 0;
2860 if (code > 15)
2861 offt++;
2862 if (code > 21)
2863 offt++;
2864 if (vt52_mode)
2865 p += sprintf((char *) p, "\x1B%c", code + 'P' - 11 - offt);
2866 else
2867 p +=
2868 sprintf((char *) p, "\x1BO%c", code + 'P' - 11 - offt);
2869 return p - output;
2870 }
2871 if (cfg.funky_type == 1 && code >= 11 && code <= 15) {
2872 p += sprintf((char *) p, "\x1B[[%c", code + 'A' - 11);
2873 return p - output;
2874 }
2875 if (cfg.funky_type == 2 && code >= 11 && code <= 14) {
2876 if (vt52_mode)
2877 p += sprintf((char *) p, "\x1B%c", code + 'P' - 11);
2878 else
2879 p += sprintf((char *) p, "\x1BO%c", code + 'P' - 11);
2880 return p - output;
2881 }
2882 if (cfg.rxvt_homeend && (code == 1 || code == 4)) {
2883 p += sprintf((char *) p, code == 1 ? "\x1B[H" : "\x1BOw");
2884 return p - output;
2885 }
2886 if (code) {
2887 p += sprintf((char *) p, "\x1B[%d~", code);
2888 return p - output;
2889 }
2890
2891 /*
2892 * Now the remaining keys (arrows and Keypad 5. Keypad 5 for
2893 * some reason seems to send VK_CLEAR to Windows...).
2894 */
2895 {
2896 char xkey = 0;
2897 switch (wParam) {
2898 case VK_UP:
2899 xkey = 'A';
2900 break;
2901 case VK_DOWN:
2902 xkey = 'B';
2903 break;
2904 case VK_RIGHT:
2905 xkey = 'C';
2906 break;
2907 case VK_LEFT:
2908 xkey = 'D';
2909 break;
2910 case VK_CLEAR:
2911 xkey = 'G';
2912 break;
2913 }
2914 if (xkey) {
2915 if (vt52_mode)
2916 p += sprintf((char *) p, "\x1B%c", xkey);
2917 else {
2918 int app_flg = (app_cursor_keys && !cfg.no_applic_c);
2919 /* VT100 & VT102 manuals both state the app cursor keys
2920 * only work if the app keypad is on.
2921 */
2922 if (!app_keypad_keys)
2923 app_flg = 0;
2924 /* Useful mapping of Ctrl-arrows */
2925 if (shift_state == 2)
2926 app_flg = !app_flg;
2927
2928 if (app_flg)
2929 p += sprintf((char *) p, "\x1BO%c", xkey);
2930 else
2931 p += sprintf((char *) p, "\x1B[%c", xkey);
2932 }
2933 return p - output;
2934 }
2935 }
2936
2937 /*
2938 * Finally, deal with Return ourselves. (Win95 seems to
2939 * foul it up when Alt is pressed, for some reason.)
2940 */
2941 if (wParam == VK_RETURN) { /* Return */
2942 *p++ = 0x0D;
2943 *p++ = 0;
2944 return -2;
2945 }
2946
2947 if (left_alt && wParam >= VK_NUMPAD0 && wParam <= VK_NUMPAD9)
2948 alt_sum = alt_sum * 10 + wParam - VK_NUMPAD0;
2949 else
2950 alt_sum = 0;
2951 }
2952
2953 /* Okay we've done everything interesting; let windows deal with
2954 * the boring stuff */
2955 {
2956 r = ToAsciiEx(wParam, scan, keystate, keys, 0, kbd_layout);
2957 #ifdef SHOW_TOASCII_RESULT
2958 if (r == 1 && !key_down) {
2959 if (alt_sum) {
2960 if (in_utf || dbcs_screenfont)
2961 debug((", (U+%04x)", alt_sum));
2962 else
2963 debug((", LCH(%d)", alt_sum));
2964 } else {
2965 debug((", ACH(%d)", keys[0]));
2966 }
2967 } else if (r > 0) {
2968 int r1;
2969 debug((", ASC("));
2970 for (r1 = 0; r1 < r; r1++) {
2971 debug(("%s%d", r1 ? "," : "", keys[r1]));
2972 }
2973 debug((")"));
2974 }
2975 #endif
2976 if (r > 0) {
2977 WCHAR keybuf;
2978 p = output;
2979 for (i = 0; i < r; i++) {
2980 unsigned char ch = (unsigned char) keys[i];
2981
2982 if (compose_state == 2 && (ch & 0x80) == 0 && ch > ' ') {
2983 compose_char = ch;
2984 compose_state++;
2985 continue;
2986 }
2987 if (compose_state == 3 && (ch & 0x80) == 0 && ch > ' ') {
2988 int nc;
2989 compose_state = 0;
2990
2991 if ((nc = check_compose(compose_char, ch)) == -1) {
2992 MessageBeep(MB_ICONHAND);
2993 return 0;
2994 }
2995 keybuf = nc;
2996 luni_send(&keybuf, 1);
2997 continue;
2998 }
2999
3000 compose_state = 0;
3001
3002 if (!key_down) {
3003 if (alt_sum) {
3004 if (in_utf || dbcs_screenfont) {
3005 keybuf = alt_sum;
3006 luni_send(&keybuf, 1);
3007 } else {
3008 ch = (char) alt_sum;
3009 /*
3010 * We need not bother about stdin
3011 * backlogs here, because in GUI PuTTY
3012 * we can't do anything about it
3013 * anyway; there's no means of asking
3014 * Windows to hold off on KEYDOWN
3015 * messages. We _have_ to buffer
3016 * everything we're sent.
3017 */
3018 ldisc_send(&ch, 1);
3019 }
3020 alt_sum = 0;
3021 } else
3022 lpage_send(kbd_codepage, &ch, 1);
3023 } else {
3024 static char cbuf[] = "\033 ";
3025 cbuf[1] = ch;
3026 lpage_send(kbd_codepage, cbuf + !left_alt,
3027 1 + !!left_alt);
3028 }
3029 }
3030
3031 /* This is so the ALT-Numpad and dead keys work correctly. */
3032 keys[0] = 0;
3033
3034 return p - output;
3035 }
3036 /* If we're definitly not building up an ALT-54321 then clear it */
3037 if (!left_alt)
3038 keys[0] = 0;
3039 /* If we will be using alt_sum fix the 256s */
3040 else if (keys[0] && (in_utf || dbcs_screenfont))
3041 keys[0] = 10;
3042 }
3043
3044 /* ALT alone may or may not want to bring up the System menu */
3045 if (wParam == VK_MENU) {
3046 if (cfg.alt_only) {
3047 if (message == WM_SYSKEYDOWN)
3048 alt_state = 1;
3049 else if (message == WM_SYSKEYUP && alt_state)
3050 PostMessage(hwnd, WM_CHAR, ' ', 0);
3051 if (message == WM_SYSKEYUP)
3052 alt_state = 0;
3053 } else
3054 return 0;
3055 } else
3056 alt_state = 0;
3057
3058 return -1;
3059 }
3060
3061 void set_title(char *title)
3062 {
3063 sfree(window_name);
3064 window_name = smalloc(1 + strlen(title));
3065 strcpy(window_name, title);
3066 if (cfg.win_name_always || !IsIconic(hwnd))
3067 SetWindowText(hwnd, title);
3068 }
3069
3070 void set_icon(char *title)
3071 {
3072 sfree(icon_name);
3073 icon_name = smalloc(1 + strlen(title));
3074 strcpy(icon_name, title);
3075 if (!cfg.win_name_always && IsIconic(hwnd))
3076 SetWindowText(hwnd, title);
3077 }
3078
3079 void set_sbar(int total, int start, int page)
3080 {
3081 SCROLLINFO si;
3082
3083 if (!cfg.scrollbar)
3084 return;
3085
3086 si.cbSize = sizeof(si);
3087 si.fMask = SIF_ALL | SIF_DISABLENOSCROLL;
3088 si.nMin = 0;
3089 si.nMax = total - 1;
3090 si.nPage = page;
3091 si.nPos = start;
3092 if (hwnd)
3093 SetScrollInfo(hwnd, SB_VERT, &si, TRUE);
3094 }
3095
3096 Context get_ctx(void)
3097 {
3098 HDC hdc;
3099 if (hwnd) {
3100 hdc = GetDC(hwnd);
3101 if (hdc && pal)
3102 SelectPalette(hdc, pal, FALSE);
3103 return hdc;
3104 } else
3105 return NULL;
3106 }
3107
3108 void free_ctx(Context ctx)
3109 {
3110 SelectPalette(ctx, GetStockObject(DEFAULT_PALETTE), FALSE);
3111 ReleaseDC(hwnd, ctx);
3112 }
3113
3114 static void real_palette_set(int n, int r, int g, int b)
3115 {
3116 if (pal) {
3117 logpal->palPalEntry[n].peRed = r;
3118 logpal->palPalEntry[n].peGreen = g;
3119 logpal->palPalEntry[n].peBlue = b;
3120 logpal->palPalEntry[n].peFlags = PC_NOCOLLAPSE;
3121 colours[n] = PALETTERGB(r, g, b);
3122 SetPaletteEntries(pal, 0, NCOLOURS, logpal->palPalEntry);
3123 } else
3124 colours[n] = RGB(r, g, b);
3125 }
3126
3127 void palette_set(int n, int r, int g, int b)
3128 {
3129 static const int first[21] = {
3130 0, 2, 4, 6, 8, 10, 12, 14,
3131 1, 3, 5, 7, 9, 11, 13, 15,
3132 16, 17, 18, 20, 22
3133 };
3134 real_palette_set(first[n], r, g, b);
3135 if (first[n] >= 18)
3136 real_palette_set(first[n] + 1, r, g, b);
3137 if (pal) {
3138 HDC hdc = get_ctx();
3139 UnrealizeObject(pal);
3140 RealizePalette(hdc);
3141 free_ctx(hdc);
3142 }
3143 }
3144
3145 void palette_reset(void)
3146 {
3147 int i;
3148
3149 for (i = 0; i < NCOLOURS; i++) {
3150 if (pal) {
3151 logpal->palPalEntry[i].peRed = defpal[i].rgbtRed;
3152 logpal->palPalEntry[i].peGreen = defpal[i].rgbtGreen;
3153 logpal->palPalEntry[i].peBlue = defpal[i].rgbtBlue;
3154 logpal->palPalEntry[i].peFlags = 0;
3155 colours[i] = PALETTERGB(defpal[i].rgbtRed,
3156 defpal[i].rgbtGreen,
3157 defpal[i].rgbtBlue);
3158 } else
3159 colours[i] = RGB(defpal[i].rgbtRed,
3160 defpal[i].rgbtGreen, defpal[i].rgbtBlue);
3161 }
3162
3163 if (pal) {
3164 HDC hdc;
3165 SetPaletteEntries(pal, 0, NCOLOURS, logpal->palPalEntry);
3166 hdc = get_ctx();
3167 RealizePalette(hdc);
3168 free_ctx(hdc);
3169 }
3170 }
3171
3172 void write_aclip(char *data, int len, int must_deselect)
3173 {
3174 HGLOBAL clipdata;
3175 void *lock;
3176
3177 clipdata = GlobalAlloc(GMEM_DDESHARE | GMEM_MOVEABLE, len + 1);
3178 if (!clipdata)
3179 return;
3180 lock = GlobalLock(clipdata);
3181 if (!lock)
3182 return;
3183 memcpy(lock, data, len);
3184 ((unsigned char *) lock)[len] = 0;
3185 GlobalUnlock(clipdata);
3186
3187 if (!must_deselect)
3188 SendMessage(hwnd, WM_IGNORE_CLIP, TRUE, 0);
3189
3190 if (OpenClipboard(hwnd)) {
3191 EmptyClipboard();
3192 SetClipboardData(CF_TEXT, clipdata);
3193 CloseClipboard();
3194 } else
3195 GlobalFree(clipdata);
3196
3197 if (!must_deselect)
3198 SendMessage(hwnd, WM_IGNORE_CLIP, FALSE, 0);
3199 }
3200
3201 /*
3202 * Note: unlike write_aclip() this will not append a nul.
3203 */
3204 void write_clip(wchar_t * data, int len, int must_deselect)
3205 {
3206 HGLOBAL clipdata;
3207 HGLOBAL clipdata2;
3208 int len2;
3209 void *lock, *lock2;
3210
3211 len2 = WideCharToMultiByte(CP_ACP, 0, data, len, 0, 0, NULL, NULL);
3212
3213 clipdata = GlobalAlloc(GMEM_DDESHARE | GMEM_MOVEABLE,
3214 len * sizeof(wchar_t));
3215 clipdata2 = GlobalAlloc(GMEM_DDESHARE | GMEM_MOVEABLE, len2);
3216
3217 if (!clipdata || !clipdata2) {
3218 if (clipdata)
3219 GlobalFree(clipdata);
3220 if (clipdata2)
3221 GlobalFree(clipdata2);
3222 return;
3223 }
3224 if (!(lock = GlobalLock(clipdata)))
3225 return;
3226 if (!(lock2 = GlobalLock(clipdata2)))
3227 return;
3228
3229 memcpy(lock, data, len * sizeof(wchar_t));
3230 WideCharToMultiByte(CP_ACP, 0, data, len, lock2, len2, NULL, NULL);
3231
3232 GlobalUnlock(clipdata);
3233 GlobalUnlock(clipdata2);
3234
3235 if (!must_deselect)
3236 SendMessage(hwnd, WM_IGNORE_CLIP, TRUE, 0);
3237
3238 if (OpenClipboard(hwnd)) {
3239 EmptyClipboard();
3240 SetClipboardData(CF_UNICODETEXT, clipdata);
3241 SetClipboardData(CF_TEXT, clipdata2);
3242 CloseClipboard();
3243 } else {
3244 GlobalFree(clipdata);
3245 GlobalFree(clipdata2);
3246 }
3247
3248 if (!must_deselect)
3249 SendMessage(hwnd, WM_IGNORE_CLIP, FALSE, 0);
3250 }
3251
3252 void get_clip(wchar_t ** p, int *len)
3253 {
3254 static HGLOBAL clipdata = NULL;
3255 static wchar_t *converted = 0;
3256 wchar_t *p2;
3257
3258 if (converted) {
3259 sfree(converted);
3260 converted = 0;
3261 }
3262 if (!p) {
3263 if (clipdata)
3264 GlobalUnlock(clipdata);
3265 clipdata = NULL;
3266 return;
3267 } else if (OpenClipboard(NULL)) {
3268 if ((clipdata = GetClipboardData(CF_UNICODETEXT))) {
3269 CloseClipboard();
3270 *p = GlobalLock(clipdata);
3271 if (*p) {
3272 for (p2 = *p; *p2; p2++);
3273 *len = p2 - *p;
3274 return;
3275 }
3276 } else if ( (clipdata = GetClipboardData(CF_TEXT)) ) {
3277 char *s;
3278 int i;
3279 CloseClipboard();
3280 s = GlobalLock(clipdata);
3281 i = MultiByteToWideChar(CP_ACP, 0, s, strlen(s) + 1, 0, 0);
3282 *p = converted = smalloc(i * sizeof(wchar_t));
3283 MultiByteToWideChar(CP_ACP, 0, s, strlen(s) + 1, converted, i);
3284 *len = i - 1;
3285 return;
3286 } else
3287 CloseClipboard();
3288 }
3289
3290 *p = NULL;
3291 *len = 0;
3292 }
3293
3294 #if 0
3295 /*
3296 * Move `lines' lines from position `from' to position `to' in the
3297 * window.
3298 */
3299 void optimised_move(int to, int from, int lines)
3300 {
3301 RECT r;
3302 int min, max;
3303
3304 min = (to < from ? to : from);
3305 max = to + from - min;
3306
3307 r.left = 0;
3308 r.right = cols * font_width;
3309 r.top = min * font_height;
3310 r.bottom = (max + lines) * font_height;
3311 ScrollWindow(hwnd, 0, (to - from) * font_height, &r, &r);
3312 }
3313 #endif
3314
3315 /*
3316 * Print a message box and perform a fatal exit.
3317 */
3318 void fatalbox(char *fmt, ...)
3319 {
3320 va_list ap;
3321 char stuff[200];
3322
3323 va_start(ap, fmt);
3324 vsprintf(stuff, fmt, ap);
3325 va_end(ap);
3326 MessageBox(hwnd, stuff, "PuTTY Fatal Error", MB_ICONERROR | MB_OK);
3327 exit(1);
3328 }
3329
3330 /*
3331 * Manage window caption / taskbar flashing, if enabled.
3332 * 0 = stop, 1 = maintain, 2 = start
3333 */
3334 static void flash_window(int mode)
3335 {
3336 static long last_flash = 0;
3337 static int flashing = 0;
3338 if ((mode == 0) || (cfg.beep_ind == B_IND_DISABLED)) {
3339 /* stop */
3340 if (flashing) {
3341 FlashWindow(hwnd, FALSE);
3342 flashing = 0;
3343 }
3344
3345 } else if (mode == 2) {
3346 /* start */
3347 if (!flashing) {
3348 last_flash = GetTickCount();
3349 flashing = 1;
3350 FlashWindow(hwnd, TRUE);
3351 }
3352
3353 } else if ((mode == 1) && (cfg.beep_ind == B_IND_FLASH)) {
3354 /* maintain */
3355 if (flashing) {
3356 long now = GetTickCount();
3357 long fdiff = now - last_flash;
3358 if (fdiff < 0 || fdiff > 450) {
3359 last_flash = now;
3360 FlashWindow(hwnd, TRUE); /* toggle */
3361 }
3362 }
3363 }
3364 }
3365
3366 /*
3367 * Beep.
3368 */
3369 void beep(int mode)
3370 {
3371 if (mode == BELL_DEFAULT) {
3372 /*
3373 * For MessageBeep style bells, we want to be careful of
3374 * timing, because they don't have the nice property of
3375 * PlaySound bells that each one cancels the previous
3376 * active one. So we limit the rate to one per 50ms or so.
3377 */
3378 static long lastbeep = 0;
3379 long beepdiff;
3380
3381 beepdiff = GetTickCount() - lastbeep;
3382 if (beepdiff >= 0 && beepdiff < 50)
3383 return;
3384 MessageBeep(MB_OK);
3385 /*
3386 * The above MessageBeep call takes time, so we record the
3387 * time _after_ it finishes rather than before it starts.
3388 */
3389 lastbeep = GetTickCount();
3390 } else if (mode == BELL_WAVEFILE) {
3391 if (!PlaySound(cfg.bell_wavefile, NULL, SND_ASYNC | SND_FILENAME)) {
3392 char buf[sizeof(cfg.bell_wavefile) + 80];
3393 sprintf(buf, "Unable to play sound file\n%s\n"
3394 "Using default sound instead", cfg.bell_wavefile);
3395 MessageBox(hwnd, buf, "PuTTY Sound Error",
3396 MB_OK | MB_ICONEXCLAMATION);
3397 cfg.beep = BELL_DEFAULT;
3398 }
3399 }
3400 /* Otherwise, either visual bell or disabled; do nothing here */
3401 if (!has_focus) {
3402 flash_window(2); /* start */
3403 }
3404 }
Local modifications for Simon Tatham's `PuTTY' SSH client and terminal emulator