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