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