Add a couple of ellipses in system menu
[sgt/putty] / window.c
1 #include <windows.h>
2 #include <imm.h>
3 #include <commctrl.h>
4 #ifndef AUTO_WINSOCK
5 #ifdef WINSOCK_TWO
6 #include <winsock2.h>
7 #else
8 #include <winsock.h>
9 #endif
10 #endif
11 #include <stdio.h>
12 #include <stdlib.h>
13 #include <ctype.h>
14 #include <time.h>
15
16 #define PUTTY_DO_GLOBALS /* actually _define_ globals */
17 #include "putty.h"
18 #include "winstuff.h"
19 #include "storage.h"
20 #include "win_res.h"
21
22 #define IDM_SHOWLOG 0x0010
23 #define IDM_NEWSESS 0x0020
24 #define IDM_DUPSESS 0x0030
25 #define IDM_RECONF 0x0040
26 #define IDM_CLRSB 0x0050
27 #define IDM_RESET 0x0060
28 #define IDM_TEL_AYT 0x0070
29 #define IDM_TEL_BRK 0x0080
30 #define IDM_TEL_SYNCH 0x0090
31 #define IDM_TEL_EC 0x00a0
32 #define IDM_TEL_EL 0x00b0
33 #define IDM_TEL_GA 0x00c0
34 #define IDM_TEL_NOP 0x00d0
35 #define IDM_TEL_ABORT 0x00e0
36 #define IDM_TEL_AO 0x00f0
37 #define IDM_TEL_IP 0x0100
38 #define IDM_TEL_SUSP 0x0110
39 #define IDM_TEL_EOR 0x0120
40 #define IDM_TEL_EOF 0x0130
41 #define IDM_ABOUT 0x0140
42 #define IDM_SAVEDSESS 0x0150
43
44 #define IDM_SAVED_MIN 0x1000
45 #define IDM_SAVED_MAX 0x2000
46
47 #define WM_IGNORE_SIZE (WM_XUSER + 1)
48 #define WM_IGNORE_CLIP (WM_XUSER + 2)
49
50 /* Needed for Chinese support and apparently not always defined. */
51 #ifndef VK_PROCESSKEY
52 #define VK_PROCESSKEY 0xE5
53 #endif
54
55 static LRESULT CALLBACK WndProc (HWND, UINT, WPARAM, LPARAM);
56 static int TranslateKey(UINT message, WPARAM wParam, LPARAM lParam, unsigned char *output);
57 static void cfgtopalette(void);
58 static void init_palette(void);
59 static void init_fonts(int);
60
61 static int extra_width, extra_height;
62
63 static int pending_netevent = 0;
64 static WPARAM pend_netevent_wParam = 0;
65 static LPARAM pend_netevent_lParam = 0;
66 static void enact_pending_netevent(void);
67
68 static time_t last_movement = 0;
69
70 #define FONT_NORMAL 0
71 #define FONT_BOLD 1
72 #define FONT_UNDERLINE 2
73 #define FONT_BOLDUND 3
74 #define FONT_OEM 4
75 #define FONT_OEMBOLD 5
76 #define FONT_OEMBOLDUND 6
77 #define FONT_OEMUND 7
78 static HFONT fonts[8];
79 static int font_needs_hand_underlining;
80 static enum {
81 BOLD_COLOURS, BOLD_SHADOW, BOLD_FONT
82 } bold_mode;
83 static enum {
84 UND_LINE, UND_FONT
85 } und_mode;
86 static int descent;
87
88 #define NCOLOURS 24
89 static COLORREF colours[NCOLOURS];
90 static HPALETTE pal;
91 static LPLOGPALETTE logpal;
92 static RGBTRIPLE defpal[NCOLOURS];
93
94 static HWND hwnd;
95
96 static HBITMAP caretbm;
97
98 static int dbltime, lasttime, lastact;
99 static Mouse_Button lastbtn;
100
101 static char *window_name, *icon_name;
102
103 static Ldisc *real_ldisc;
104
105 void begin_session(void) {
106 ldisc = real_ldisc;
107 }
108
109 int WINAPI WinMain(HINSTANCE inst, HINSTANCE prev, LPSTR cmdline, int show) {
110 static char appname[] = "PuTTY";
111 WORD winsock_ver;
112 WSADATA wsadata;
113 WNDCLASS wndclass;
114 MSG msg;
115 int guess_width, guess_height;
116
117 hinst = inst;
118 flags = FLAG_VERBOSE | FLAG_INTERACTIVE;
119
120 winsock_ver = MAKEWORD(1, 1);
121 if (WSAStartup(winsock_ver, &wsadata)) {
122 MessageBox(NULL, "Unable to initialise WinSock", "WinSock Error",
123 MB_OK | MB_ICONEXCLAMATION);
124 return 1;
125 }
126 if (LOBYTE(wsadata.wVersion) != 1 || HIBYTE(wsadata.wVersion) != 1) {
127 MessageBox(NULL, "WinSock version is incompatible with 1.1",
128 "WinSock Error", MB_OK | MB_ICONEXCLAMATION);
129 WSACleanup();
130 return 1;
131 }
132 /* WISHLIST: maybe allow config tweaking even if winsock not present? */
133 sk_init();
134
135 InitCommonControls();
136
137 /* Ensure a Maximize setting in Explorer doesn't maximise the
138 * config box. */
139 defuse_showwindow();
140
141 /*
142 * Process the command line.
143 */
144 {
145 char *p;
146
147 default_protocol = DEFAULT_PROTOCOL;
148 default_port = DEFAULT_PORT;
149
150 do_defaults(NULL, &cfg);
151
152 p = cmdline;
153 while (*p && isspace(*p)) p++;
154
155 /*
156 * Process command line options first. Yes, this can be
157 * done better, and it will be as soon as I have the
158 * energy...
159 */
160 while (*p == '-') {
161 char *q = p + strcspn(p, " \t");
162 p++;
163 if (q == p + 3 &&
164 tolower(p[0]) == 's' &&
165 tolower(p[1]) == 's' &&
166 tolower(p[2]) == 'h') {
167 default_protocol = cfg.protocol = PROT_SSH;
168 default_port = cfg.port = 22;
169 } else if (q == p + 3 &&
170 tolower(p[0]) == 'l' &&
171 tolower(p[1]) == 'o' &&
172 tolower(p[2]) == 'g') {
173 logfile = "putty.log";
174 } else if (q == p + 7 &&
175 tolower(p[0]) == 'c' &&
176 tolower(p[1]) == 'l' &&
177 tolower(p[2]) == 'e' &&
178 tolower(p[3]) == 'a' &&
179 tolower(p[4]) == 'n' &&
180 tolower(p[5]) == 'u' &&
181 tolower(p[6]) == 'p') {
182 /*
183 * `putty -cleanup'. Remove all registry entries
184 * associated with PuTTY, and also find and delete
185 * the random seed file.
186 */
187 if (MessageBox(NULL,
188 "This procedure will remove ALL Registry\n"
189 "entries associated with PuTTY, and will\n"
190 "also remove the PuTTY random seed file.\n"
191 "\n"
192 "THIS PROCESS WILL DESTROY YOUR SAVED\n"
193 "SESSIONS. Are you really sure you want\n"
194 "to continue?",
195 "PuTTY Warning",
196 MB_YESNO | MB_ICONWARNING) == IDYES) {
197 cleanup_all();
198 }
199 exit(0);
200 }
201 p = q + strspn(q, " \t");
202 }
203
204 /*
205 * An initial @ means to activate a saved session.
206 */
207 if (*p == '@') {
208 int i = strlen(p);
209 while (i > 1 && isspace(p[i-1]))
210 i--;
211 p[i] = '\0';
212 do_defaults (p+1, &cfg);
213 if (!*cfg.host && !do_config()) {
214 WSACleanup();
215 return 0;
216 }
217 } else if (*p == '&') {
218 /*
219 * An initial & means we've been given a command line
220 * containing the hex value of a HANDLE for a file
221 * mapping object, which we must then extract as a
222 * config.
223 */
224 HANDLE filemap;
225 Config *cp;
226 if (sscanf(p+1, "%p", &filemap) == 1 &&
227 (cp = MapViewOfFile(filemap, FILE_MAP_READ,
228 0, 0, sizeof(Config))) != NULL) {
229 cfg = *cp;
230 UnmapViewOfFile(cp);
231 CloseHandle(filemap);
232 } else if (!do_config()) {
233 WSACleanup();
234 return 0;
235 }
236 } else if (*p) {
237 char *q = p;
238 /*
239 * If the hostname starts with "telnet:", set the
240 * protocol to Telnet and process the string as a
241 * Telnet URL.
242 */
243 if (!strncmp(q, "telnet:", 7)) {
244 char c;
245
246 q += 7;
247 if (q[0] == '/' && q[1] == '/')
248 q += 2;
249 cfg.protocol = PROT_TELNET;
250 p = q;
251 while (*p && *p != ':' && *p != '/') p++;
252 c = *p;
253 if (*p)
254 *p++ = '\0';
255 if (c == ':')
256 cfg.port = atoi(p);
257 else
258 cfg.port = -1;
259 strncpy (cfg.host, q, sizeof(cfg.host)-1);
260 cfg.host[sizeof(cfg.host)-1] = '\0';
261 } else {
262 while (*p && !isspace(*p)) p++;
263 if (*p)
264 *p++ = '\0';
265 strncpy (cfg.host, q, sizeof(cfg.host)-1);
266 cfg.host[sizeof(cfg.host)-1] = '\0';
267 while (*p && isspace(*p)) p++;
268 if (*p)
269 cfg.port = atoi(p);
270 else
271 cfg.port = -1;
272 }
273 } else {
274 if (!do_config()) {
275 WSACleanup();
276 return 0;
277 }
278 }
279
280 /* See if host is of the form user@host */
281 if (cfg.host[0] != '\0') {
282 char *atsign = strchr(cfg.host, '@');
283 /* Make sure we're not overflowing the user field */
284 if (atsign) {
285 if (atsign-cfg.host < sizeof cfg.username) {
286 strncpy (cfg.username, cfg.host, atsign-cfg.host);
287 cfg.username[atsign-cfg.host] = '\0';
288 }
289 memmove(cfg.host, atsign+1, 1+strlen(atsign+1));
290 }
291 }
292 }
293
294 /*
295 * Select protocol. This is farmed out into a table in a
296 * separate file to enable an ssh-free variant.
297 */
298 {
299 int i;
300 back = NULL;
301 for (i = 0; backends[i].backend != NULL; i++)
302 if (backends[i].protocol == cfg.protocol) {
303 back = backends[i].backend;
304 break;
305 }
306 if (back == NULL) {
307 MessageBox(NULL, "Unsupported protocol number found",
308 "PuTTY Internal Error", MB_OK | MB_ICONEXCLAMATION);
309 WSACleanup();
310 return 1;
311 }
312 }
313
314 real_ldisc = (cfg.ldisc_term ? &ldisc_term : &ldisc_simple);
315 /* To start with, we use the simple line discipline, so we can
316 * type passwords etc without fear of them being echoed... */
317 ldisc = &ldisc_simple;
318
319 if (!prev) {
320 wndclass.style = 0;
321 wndclass.lpfnWndProc = WndProc;
322 wndclass.cbClsExtra = 0;
323 wndclass.cbWndExtra = 0;
324 wndclass.hInstance = inst;
325 wndclass.hIcon = LoadIcon (inst,
326 MAKEINTRESOURCE(IDI_MAINICON));
327 wndclass.hCursor = LoadCursor (NULL, IDC_IBEAM);
328 wndclass.hbrBackground = GetStockObject (BLACK_BRUSH);
329 wndclass.lpszMenuName = NULL;
330 wndclass.lpszClassName = appname;
331
332 RegisterClass (&wndclass);
333 }
334
335 hwnd = NULL;
336
337 savelines = cfg.savelines;
338 term_init();
339
340 cfgtopalette();
341
342 /*
343 * Guess some defaults for the window size. This all gets
344 * updated later, so we don't really care too much. However, we
345 * do want the font width/height guesses to correspond to a
346 * large font rather than a small one...
347 */
348
349 font_width = 10;
350 font_height = 20;
351 extra_width = 25;
352 extra_height = 28;
353 term_size (cfg.height, cfg.width, cfg.savelines);
354 guess_width = extra_width + font_width * cols;
355 guess_height = extra_height + font_height * rows;
356 {
357 RECT r;
358 HWND w = GetDesktopWindow();
359 GetWindowRect (w, &r);
360 if (guess_width > r.right - r.left)
361 guess_width = r.right - r.left;
362 if (guess_height > r.bottom - r.top)
363 guess_height = r.bottom - r.top;
364 }
365
366 {
367 int winmode = WS_OVERLAPPEDWINDOW|WS_VSCROLL;
368 if (!cfg.scrollbar) winmode &= ~(WS_VSCROLL);
369 if (cfg.locksize) winmode &= ~(WS_THICKFRAME|WS_MAXIMIZEBOX);
370 hwnd = CreateWindow (appname, appname,
371 winmode,
372 CW_USEDEFAULT, CW_USEDEFAULT,
373 guess_width, guess_height,
374 NULL, NULL, inst, NULL);
375 }
376
377 /*
378 * Initialise the fonts, simultaneously correcting the guesses
379 * for font_{width,height}.
380 */
381 bold_mode = cfg.bold_colour ? BOLD_COLOURS : BOLD_FONT;
382 und_mode = UND_FONT;
383 init_fonts(0);
384
385 /*
386 * Correct the guesses for extra_{width,height}.
387 */
388 {
389 RECT cr, wr;
390 GetWindowRect (hwnd, &wr);
391 GetClientRect (hwnd, &cr);
392 extra_width = wr.right - wr.left - cr.right + cr.left;
393 extra_height = wr.bottom - wr.top - cr.bottom + cr.top;
394 }
395
396 /*
397 * Resize the window, now we know what size we _really_ want it
398 * to be.
399 */
400 guess_width = extra_width + font_width * cols;
401 guess_height = extra_height + font_height * rows;
402 SendMessage (hwnd, WM_IGNORE_SIZE, 0, 0);
403 SetWindowPos (hwnd, NULL, 0, 0, guess_width, guess_height,
404 SWP_NOMOVE | SWP_NOREDRAW | SWP_NOZORDER);
405
406 /*
407 * Set up a caret bitmap, with no content.
408 */
409 {
410 char *bits;
411 int size = (font_width+15)/16 * 2 * font_height;
412 bits = calloc(size, 1);
413 caretbm = CreateBitmap(font_width, font_height, 1, 1, bits);
414 free(bits);
415 }
416
417 /*
418 * Initialise the scroll bar.
419 */
420 {
421 SCROLLINFO si;
422
423 si.cbSize = sizeof(si);
424 si.fMask = SIF_ALL | SIF_DISABLENOSCROLL;
425 si.nMin = 0;
426 si.nMax = rows-1;
427 si.nPage = rows;
428 si.nPos = 0;
429 SetScrollInfo (hwnd, SB_VERT, &si, FALSE);
430 }
431
432 /*
433 * Start up the telnet connection.
434 */
435 {
436 char *error;
437 char msg[1024], *title;
438 char *realhost;
439
440 error = back->init (cfg.host, cfg.port, &realhost);
441 if (error) {
442 sprintf(msg, "Unable to open connection:\n%s", error);
443 MessageBox(NULL, msg, "PuTTY Error", MB_ICONERROR | MB_OK);
444 return 0;
445 }
446 window_name = icon_name = NULL;
447 if (*cfg.wintitle) {
448 title = cfg.wintitle;
449 } else {
450 sprintf(msg, "%s - PuTTY", realhost);
451 title = msg;
452 }
453 set_title (title);
454 set_icon (title);
455 }
456
457 session_closed = FALSE;
458
459 /*
460 * Set up the input and output buffers.
461 */
462 inbuf_head = 0;
463 outbuf_reap = outbuf_head = 0;
464
465 /*
466 * Prepare the mouse handler.
467 */
468 lastact = MA_NOTHING;
469 lastbtn = MB_NOTHING;
470 dbltime = GetDoubleClickTime();
471
472 /*
473 * Set up the session-control options on the system menu.
474 */
475 {
476 HMENU m = GetSystemMenu (hwnd, FALSE);
477 HMENU p,s;
478 int i;
479
480 AppendMenu (m, MF_SEPARATOR, 0, 0);
481 if (cfg.protocol == PROT_TELNET) {
482 p = CreateMenu();
483 AppendMenu (p, MF_ENABLED, IDM_TEL_AYT, "Are You There");
484 AppendMenu (p, MF_ENABLED, IDM_TEL_BRK, "Break");
485 AppendMenu (p, MF_ENABLED, IDM_TEL_SYNCH, "Synch");
486 AppendMenu (p, MF_SEPARATOR, 0, 0);
487 AppendMenu (p, MF_ENABLED, IDM_TEL_EC, "Erase Character");
488 AppendMenu (p, MF_ENABLED, IDM_TEL_EL, "Erase Line");
489 AppendMenu (p, MF_ENABLED, IDM_TEL_GA, "Go Ahead");
490 AppendMenu (p, MF_ENABLED, IDM_TEL_NOP, "No Operation");
491 AppendMenu (p, MF_SEPARATOR, 0, 0);
492 AppendMenu (p, MF_ENABLED, IDM_TEL_ABORT, "Abort Process");
493 AppendMenu (p, MF_ENABLED, IDM_TEL_AO, "Abort Output");
494 AppendMenu (p, MF_ENABLED, IDM_TEL_IP, "Interrupt Process");
495 AppendMenu (p, MF_ENABLED, IDM_TEL_SUSP, "Suspend Process");
496 AppendMenu (p, MF_SEPARATOR, 0, 0);
497 AppendMenu (p, MF_ENABLED, IDM_TEL_EOR, "End Of Record");
498 AppendMenu (p, MF_ENABLED, IDM_TEL_EOF, "End Of File");
499 AppendMenu (m, MF_POPUP | MF_ENABLED, (UINT) p, "Telnet Command");
500 AppendMenu (m, MF_SEPARATOR, 0, 0);
501 }
502 AppendMenu (m, MF_ENABLED, IDM_SHOWLOG, "&Event Log");
503 AppendMenu (m, MF_SEPARATOR, 0, 0);
504 AppendMenu (m, MF_ENABLED, IDM_NEWSESS, "Ne&w Session...");
505 AppendMenu (m, MF_ENABLED, IDM_DUPSESS, "&Duplicate Session");
506 s = CreateMenu();
507 get_sesslist(TRUE);
508 for (i = 1 ; i < ((nsessions < 256) ? nsessions : 256) ; i++)
509 AppendMenu (s, MF_ENABLED, IDM_SAVED_MIN + (16 * i) , sessions[i]);
510 AppendMenu (m, MF_POPUP | MF_ENABLED, (UINT) s, "Sa&ved Sessions");
511 AppendMenu (m, MF_ENABLED, IDM_RECONF, "Chan&ge Settings...");
512 AppendMenu (m, MF_SEPARATOR, 0, 0);
513 AppendMenu (m, MF_ENABLED, IDM_CLRSB, "C&lear Scrollback");
514 AppendMenu (m, MF_ENABLED, IDM_RESET, "Rese&t Terminal");
515 AppendMenu (m, MF_SEPARATOR, 0, 0);
516 AppendMenu (m, MF_ENABLED, IDM_ABOUT, "&About PuTTY");
517 }
518
519 /*
520 * Finally show the window!
521 */
522 ShowWindow (hwnd, show);
523
524 /*
525 * Set the palette up.
526 */
527 pal = NULL;
528 logpal = NULL;
529 init_palette();
530
531 has_focus = (GetForegroundWindow() == hwnd);
532 UpdateWindow (hwnd);
533
534 if (GetMessage (&msg, NULL, 0, 0) == 1)
535 {
536 int timer_id = 0, long_timer = 0;
537
538 while (msg.message != WM_QUIT) {
539 /* Sometimes DispatchMessage calls routines that use their own
540 * GetMessage loop, setup this timer so we get some control back.
541 *
542 * Also call term_update() from the timer so that if the host
543 * is sending data flat out we still do redraws.
544 */
545 if(timer_id && long_timer) {
546 KillTimer(hwnd, timer_id);
547 long_timer = timer_id = 0;
548 }
549 if(!timer_id)
550 timer_id = SetTimer(hwnd, 1, 20, NULL);
551 DispatchMessage (&msg);
552
553 /* Make sure we blink everything that needs it. */
554 term_blink(0);
555
556 /* Send the paste buffer if there's anything to send */
557 term_paste();
558
559 /* If there's nothing new in the queue then we can do everything
560 * we've delayed, reading the socket, writing, and repainting
561 * the window.
562 */
563 if (PeekMessage (&msg, NULL, 0, 0, PM_REMOVE))
564 continue;
565
566 if (pending_netevent) {
567 enact_pending_netevent();
568
569 /* Force the cursor blink on */
570 term_blink(1);
571
572 if (PeekMessage (&msg, NULL, 0, 0, PM_REMOVE))
573 continue;
574 }
575
576 /* Okay there is now nothing to do so we make sure the screen is
577 * completely up to date then tell windows to call us in a little
578 * while.
579 */
580 if (timer_id) {
581 KillTimer(hwnd, timer_id);
582 timer_id = 0;
583 }
584 HideCaret(hwnd);
585 if (inbuf_head)
586 term_out();
587 term_update();
588 ShowCaret(hwnd);
589 if (!has_focus)
590 timer_id = SetTimer(hwnd, 1, 59500, NULL);
591 else
592 timer_id = SetTimer(hwnd, 1, 250, NULL);
593 long_timer = 1;
594
595 /* There's no point rescanning everything in the message queue
596 * so we do an apperently unneccesary wait here
597 */
598 WaitMessage();
599 if (GetMessage (&msg, NULL, 0, 0) != 1)
600 break;
601 }
602 }
603
604 /*
605 * Clean up.
606 */
607 {
608 int i;
609 for (i=0; i<8; i++)
610 if (fonts[i])
611 DeleteObject(fonts[i]);
612 }
613 sfree(logpal);
614 if (pal)
615 DeleteObject(pal);
616 WSACleanup();
617
618 if (cfg.protocol == PROT_SSH) {
619 random_save_seed();
620 #ifdef MSCRYPTOAPI
621 crypto_wrapup();
622 #endif
623 }
624
625 return msg.wParam;
626 }
627
628 /*
629 * Set up, or shut down, an AsyncSelect. Called from winnet.c.
630 */
631 char *do_select(SOCKET skt, int startup) {
632 int msg, events;
633 if (startup) {
634 msg = WM_NETEVENT;
635 events = FD_READ | FD_WRITE | FD_OOB | FD_CLOSE;
636 } else {
637 msg = events = 0;
638 }
639 if (!hwnd)
640 return "do_select(): internal error (hwnd==NULL)";
641 if (WSAAsyncSelect (skt, hwnd, msg, events) == SOCKET_ERROR) {
642 switch (WSAGetLastError()) {
643 case WSAENETDOWN: return "Network is down";
644 default: return "WSAAsyncSelect(): unknown error";
645 }
646 }
647 return NULL;
648 }
649
650 /*
651 * Print a message box and close the connection.
652 */
653 void connection_fatal(char *fmt, ...) {
654 va_list ap;
655 char stuff[200];
656
657 va_start(ap, fmt);
658 vsprintf(stuff, fmt, ap);
659 va_end(ap);
660 MessageBox(hwnd, stuff, "PuTTY Fatal Error", MB_ICONERROR | MB_OK);
661 if (cfg.close_on_exit)
662 PostQuitMessage(1);
663 else {
664 session_closed = TRUE;
665 SetWindowText (hwnd, "PuTTY (inactive)");
666 }
667 }
668
669 /*
670 * Actually do the job requested by a WM_NETEVENT
671 */
672 static void enact_pending_netevent(void) {
673 static int reentering = 0;
674 extern int select_result(WPARAM, LPARAM);
675 int ret;
676
677 if (reentering)
678 return; /* don't unpend the pending */
679
680 pending_netevent = FALSE;
681
682 reentering = 1;
683 ret = select_result (pend_netevent_wParam, pend_netevent_lParam);
684 reentering = 0;
685
686 if (ret == 0) {
687 if (cfg.close_on_exit)
688 PostQuitMessage(0);
689 else {
690 session_closed = TRUE;
691 MessageBox(hwnd, "Connection closed by remote host",
692 "PuTTY", MB_OK | MB_ICONINFORMATION);
693 SetWindowText (hwnd, "PuTTY (inactive)");
694 }
695 }
696 }
697
698 /*
699 * Copy the colour palette from the configuration data into defpal.
700 * This is non-trivial because the colour indices are different.
701 */
702 static void cfgtopalette(void) {
703 int i;
704 static const int ww[] = {
705 6, 7, 8, 9, 10, 11, 12, 13,
706 14, 15, 16, 17, 18, 19, 20, 21,
707 0, 1, 2, 3, 4, 4, 5, 5
708 };
709
710 for (i=0; i<24; i++) {
711 int w = ww[i];
712 defpal[i].rgbtRed = cfg.colours[w][0];
713 defpal[i].rgbtGreen = cfg.colours[w][1];
714 defpal[i].rgbtBlue = cfg.colours[w][2];
715 }
716 }
717
718 /*
719 * Set up the colour palette.
720 */
721 static void init_palette(void) {
722 int i;
723 HDC hdc = GetDC (hwnd);
724 if (hdc) {
725 if (cfg.try_palette &&
726 GetDeviceCaps (hdc, RASTERCAPS) & RC_PALETTE) {
727 logpal = smalloc(sizeof(*logpal)
728 - sizeof(logpal->palPalEntry)
729 + NCOLOURS * sizeof(PALETTEENTRY));
730 logpal->palVersion = 0x300;
731 logpal->palNumEntries = NCOLOURS;
732 for (i = 0; i < NCOLOURS; i++) {
733 logpal->palPalEntry[i].peRed = defpal[i].rgbtRed;
734 logpal->palPalEntry[i].peGreen = defpal[i].rgbtGreen;
735 logpal->palPalEntry[i].peBlue = defpal[i].rgbtBlue;
736 logpal->palPalEntry[i].peFlags = PC_NOCOLLAPSE;
737 }
738 pal = CreatePalette (logpal);
739 if (pal) {
740 SelectPalette (hdc, pal, FALSE);
741 RealizePalette (hdc);
742 SelectPalette (hdc, GetStockObject (DEFAULT_PALETTE),
743 FALSE);
744 }
745 }
746 ReleaseDC (hwnd, hdc);
747 }
748 if (pal)
749 for (i=0; i<NCOLOURS; i++)
750 colours[i] = PALETTERGB(defpal[i].rgbtRed,
751 defpal[i].rgbtGreen,
752 defpal[i].rgbtBlue);
753 else
754 for(i=0; i<NCOLOURS; i++)
755 colours[i] = RGB(defpal[i].rgbtRed,
756 defpal[i].rgbtGreen,
757 defpal[i].rgbtBlue);
758 }
759
760 /*
761 * Initialise all the fonts we will need. There may be as many as
762 * eight or as few as one. We also:
763 *
764 * - check the font width and height, correcting our guesses if
765 * necessary.
766 *
767 * - verify that the bold font is the same width as the ordinary
768 * one, and engage shadow bolding if not.
769 *
770 * - verify that the underlined font is the same width as the
771 * ordinary one (manual underlining by means of line drawing can
772 * be done in a pinch).
773 */
774 static void init_fonts(int pick_width) {
775 TEXTMETRIC tm;
776 int i;
777 int fsize[8];
778 HDC hdc;
779 int fw_dontcare, fw_bold;
780 int firstchar = ' ';
781
782 #ifdef CHECKOEMFONT
783 font_messup:
784 #endif
785 for (i=0; i<8; i++)
786 fonts[i] = NULL;
787
788 if (cfg.fontisbold) {
789 fw_dontcare = FW_BOLD;
790 fw_bold = FW_HEAVY;
791 } else {
792 fw_dontcare = FW_DONTCARE;
793 fw_bold = FW_BOLD;
794 }
795
796 hdc = GetDC(hwnd);
797
798 font_height = cfg.fontheight;
799 font_width = pick_width;
800
801 #define f(i,c,w,u) \
802 fonts[i] = CreateFont (font_height, font_width, 0, 0, w, FALSE, u, FALSE, \
803 c, OUT_DEFAULT_PRECIS, \
804 CLIP_DEFAULT_PRECIS, DEFAULT_QUALITY, \
805 FIXED_PITCH | FF_DONTCARE, cfg.font)
806
807 if (cfg.vtmode != VT_OEMONLY) {
808 f(FONT_NORMAL, cfg.fontcharset, fw_dontcare, FALSE);
809
810 SelectObject (hdc, fonts[FONT_NORMAL]);
811 GetTextMetrics(hdc, &tm);
812 font_height = tm.tmHeight;
813 font_width = tm.tmAveCharWidth;
814
815 f(FONT_UNDERLINE, cfg.fontcharset, fw_dontcare, TRUE);
816
817 /*
818 * Some fonts, e.g. 9-pt Courier, draw their underlines
819 * outside their character cell. We successfully prevent
820 * screen corruption by clipping the text output, but then
821 * we lose the underline completely. Here we try to work
822 * out whether this is such a font, and if it is, we set a
823 * flag that causes underlines to be drawn by hand.
824 *
825 * Having tried other more sophisticated approaches (such
826 * as examining the TEXTMETRIC structure or requesting the
827 * height of a string), I think we'll do this the brute
828 * force way: we create a small bitmap, draw an underlined
829 * space on it, and test to see whether any pixels are
830 * foreground-coloured. (Since we expect the underline to
831 * go all the way across the character cell, we only search
832 * down a single column of the bitmap, half way across.)
833 */
834 {
835 HDC und_dc;
836 HBITMAP und_bm, und_oldbm;
837 int i, gotit;
838 COLORREF c;
839
840 und_dc = CreateCompatibleDC(hdc);
841 und_bm = CreateCompatibleBitmap(hdc, font_width, font_height);
842 und_oldbm = SelectObject(und_dc, und_bm);
843 SelectObject(und_dc, fonts[FONT_UNDERLINE]);
844 SetTextAlign(und_dc, TA_TOP | TA_LEFT | TA_NOUPDATECP);
845 SetTextColor (und_dc, RGB(255,255,255));
846 SetBkColor (und_dc, RGB(0,0,0));
847 SetBkMode (und_dc, OPAQUE);
848 ExtTextOut (und_dc, 0, 0, ETO_OPAQUE, NULL, " ", 1, NULL);
849 gotit = FALSE;
850 for (i = 0; i < font_height; i++) {
851 c = GetPixel(und_dc, font_width/2, i);
852 if (c != RGB(0,0,0))
853 gotit = TRUE;
854 }
855 SelectObject(und_dc, und_oldbm);
856 DeleteObject(und_bm);
857 DeleteDC(und_dc);
858 font_needs_hand_underlining = !gotit;
859 }
860
861 if (bold_mode == BOLD_FONT) {
862 f(FONT_BOLD, cfg.fontcharset, fw_bold, FALSE);
863 f(FONT_BOLDUND, cfg.fontcharset, fw_bold, TRUE);
864 }
865
866 if (cfg.vtmode == VT_OEMANSI) {
867 f(FONT_OEM, OEM_CHARSET, fw_dontcare, FALSE);
868 f(FONT_OEMUND, OEM_CHARSET, fw_dontcare, TRUE);
869
870 if (bold_mode == BOLD_FONT) {
871 f(FONT_OEMBOLD, OEM_CHARSET, fw_bold, FALSE);
872 f(FONT_OEMBOLDUND, OEM_CHARSET, fw_bold, TRUE);
873 }
874 }
875 }
876 else
877 {
878 f(FONT_OEM, cfg.fontcharset, fw_dontcare, FALSE);
879
880 SelectObject (hdc, fonts[FONT_OEM]);
881 GetTextMetrics(hdc, &tm);
882 font_height = tm.tmHeight;
883 font_width = tm.tmAveCharWidth;
884
885 f(FONT_OEMUND, cfg.fontcharset, fw_dontcare, TRUE);
886
887 if (bold_mode == BOLD_FONT) {
888 f(FONT_BOLD, cfg.fontcharset, fw_bold, FALSE);
889 f(FONT_BOLDUND, cfg.fontcharset, fw_bold, TRUE);
890 }
891 }
892 #undef f
893
894 descent = tm.tmAscent + 1;
895 if (descent >= font_height)
896 descent = font_height - 1;
897 firstchar = tm.tmFirstChar;
898
899 for (i=0; i<8; i++) {
900 if (fonts[i]) {
901 if (SelectObject (hdc, fonts[i]) &&
902 GetTextMetrics(hdc, &tm) )
903 fsize[i] = tm.tmAveCharWidth + 256 * tm.tmHeight;
904 else fsize[i] = -i;
905 }
906 else fsize[i] = -i;
907 }
908
909 ReleaseDC (hwnd, hdc);
910
911 /* ... This is wrong in OEM only mode */
912 if (fsize[FONT_UNDERLINE] != fsize[FONT_NORMAL] ||
913 (bold_mode == BOLD_FONT &&
914 fsize[FONT_BOLDUND] != fsize[FONT_BOLD])) {
915 und_mode = UND_LINE;
916 DeleteObject (fonts[FONT_UNDERLINE]);
917 if (bold_mode == BOLD_FONT)
918 DeleteObject (fonts[FONT_BOLDUND]);
919 }
920
921 if (bold_mode == BOLD_FONT &&
922 fsize[FONT_BOLD] != fsize[FONT_NORMAL]) {
923 bold_mode = BOLD_SHADOW;
924 DeleteObject (fonts[FONT_BOLD]);
925 if (und_mode == UND_FONT)
926 DeleteObject (fonts[FONT_BOLDUND]);
927 }
928
929 #ifdef CHECKOEMFONT
930 /* With the fascist font painting it doesn't matter if the linedraw font
931 * isn't exactly the right size anymore so we don't have to check this.
932 */
933 if (cfg.vtmode == VT_OEMANSI && fsize[FONT_OEM] != fsize[FONT_NORMAL] ) {
934 if( cfg.fontcharset == OEM_CHARSET )
935 {
936 MessageBox(NULL, "The OEM and ANSI versions of this font are\n"
937 "different sizes. Using OEM-only mode instead",
938 "Font Size Mismatch", MB_ICONINFORMATION | MB_OK);
939 cfg.vtmode = VT_OEMONLY;
940 }
941 else if( firstchar < ' ' )
942 {
943 MessageBox(NULL, "The OEM and ANSI versions of this font are\n"
944 "different sizes. Using XTerm mode instead",
945 "Font Size Mismatch", MB_ICONINFORMATION | MB_OK);
946 cfg.vtmode = VT_XWINDOWS;
947 }
948 else
949 {
950 MessageBox(NULL, "The OEM and ANSI versions of this font are\n"
951 "different sizes. Using ISO8859-1 mode instead",
952 "Font Size Mismatch", MB_ICONINFORMATION | MB_OK);
953 cfg.vtmode = VT_POORMAN;
954 }
955
956 for (i=0; i<8; i++)
957 if (fonts[i])
958 DeleteObject (fonts[i]);
959 goto font_messup;
960 }
961 #endif
962 }
963
964 void request_resize (int w, int h, int refont) {
965 int width, height;
966
967 /* If the window is maximized supress resizing attempts */
968 if(IsZoomed(hwnd)) return;
969
970 #ifdef CHECKOEMFONT
971 /* Don't do this in OEMANSI, you may get disable messages */
972 if (refont && w != cols && (cols==80 || cols==132)
973 && cfg.vtmode != VT_OEMANSI)
974 #else
975 if (refont && w != cols && (cols==80 || cols==132))
976 #endif
977 {
978 /* If font width too big for screen should we shrink the font more ? */
979 if (w==132)
980 font_width = ((font_width*cols+w/2)/w);
981 else
982 font_width = 0;
983 {
984 int i;
985 for (i=0; i<8; i++)
986 if (fonts[i])
987 DeleteObject(fonts[i]);
988 }
989 bold_mode = cfg.bold_colour ? BOLD_COLOURS : BOLD_FONT;
990 und_mode = UND_FONT;
991 init_fonts(font_width);
992 }
993 else
994 {
995 static int first_time = 1;
996 static RECT ss;
997
998 switch(first_time)
999 {
1000 case 1:
1001 /* Get the size of the screen */
1002 if (GetClientRect(GetDesktopWindow(),&ss))
1003 /* first_time = 0 */;
1004 else { first_time = 2; break; }
1005 case 0:
1006 /* Make sure the values are sane */
1007 width = (ss.right-ss.left-extra_width ) / font_width;
1008 height = (ss.bottom-ss.top-extra_height ) / font_height;
1009
1010 if (w>width) w=width;
1011 if (h>height) h=height;
1012 if (w<15) w = 15;
1013 if (h<1) w = 1;
1014 }
1015 }
1016
1017 width = extra_width + font_width * w;
1018 height = extra_height + font_height * h;
1019
1020 SetWindowPos (hwnd, NULL, 0, 0, width, height,
1021 SWP_NOACTIVATE | SWP_NOCOPYBITS |
1022 SWP_NOMOVE | SWP_NOZORDER);
1023 }
1024
1025 static void click (Mouse_Button b, int x, int y) {
1026 int thistime = GetMessageTime();
1027
1028 if (lastbtn == b && thistime - lasttime < dbltime) {
1029 lastact = (lastact == MA_CLICK ? MA_2CLK :
1030 lastact == MA_2CLK ? MA_3CLK :
1031 lastact == MA_3CLK ? MA_CLICK : MA_NOTHING);
1032 } else {
1033 lastbtn = b;
1034 lastact = MA_CLICK;
1035 }
1036 if (lastact != MA_NOTHING)
1037 term_mouse (b, lastact, x, y);
1038 lasttime = thistime;
1039 }
1040
1041 static LRESULT CALLBACK WndProc (HWND hwnd, UINT message,
1042 WPARAM wParam, LPARAM lParam) {
1043 HDC hdc;
1044 static int ignore_size = FALSE;
1045 static int ignore_clip = FALSE;
1046 static int just_reconfigged = FALSE;
1047 static int resizing = FALSE;
1048
1049 switch (message) {
1050 case WM_TIMER:
1051 if (pending_netevent)
1052 enact_pending_netevent();
1053 if (inbuf_head)
1054 term_out();
1055 noise_regular();
1056 HideCaret(hwnd);
1057 term_update();
1058 ShowCaret(hwnd);
1059 if (cfg.ping_interval > 0)
1060 {
1061 time_t now;
1062 time(&now);
1063 if (now-last_movement > cfg.ping_interval * 60 - 10)
1064 {
1065 back->special(TS_PING);
1066 last_movement = now;
1067 }
1068 }
1069 return 0;
1070 case WM_CREATE:
1071 break;
1072 case WM_CLOSE:
1073 if (!cfg.warn_on_close || session_closed ||
1074 MessageBox(hwnd, "Are you sure you want to close this session?",
1075 "PuTTY Exit Confirmation",
1076 MB_ICONWARNING | MB_OKCANCEL) == IDOK)
1077 DestroyWindow(hwnd);
1078 return 0;
1079 case WM_DESTROY:
1080 PostQuitMessage (0);
1081 return 0;
1082 case WM_SYSCOMMAND:
1083 switch (wParam & ~0xF) { /* low 4 bits reserved to Windows */
1084 case IDM_SHOWLOG:
1085 showeventlog(hwnd);
1086 break;
1087 case IDM_NEWSESS:
1088 case IDM_DUPSESS:
1089 case IDM_SAVEDSESS:
1090 {
1091 char b[2048];
1092 char c[30], *cl;
1093 int freecl = FALSE;
1094 STARTUPINFO si;
1095 PROCESS_INFORMATION pi;
1096 HANDLE filemap = NULL;
1097
1098 if (wParam == IDM_DUPSESS) {
1099 /*
1100 * Allocate a file-mapping memory chunk for the
1101 * config structure.
1102 */
1103 SECURITY_ATTRIBUTES sa;
1104 Config *p;
1105
1106 sa.nLength = sizeof(sa);
1107 sa.lpSecurityDescriptor = NULL;
1108 sa.bInheritHandle = TRUE;
1109 filemap = CreateFileMapping((HANDLE)0xFFFFFFFF,
1110 &sa,
1111 PAGE_READWRITE,
1112 0,
1113 sizeof(Config),
1114 NULL);
1115 if (filemap) {
1116 p = (Config *)MapViewOfFile(filemap,
1117 FILE_MAP_WRITE,
1118 0, 0, sizeof(Config));
1119 if (p) {
1120 *p = cfg; /* structure copy */
1121 UnmapViewOfFile(p);
1122 }
1123 }
1124 sprintf(c, "putty &%p", filemap);
1125 cl = c;
1126 } else if (wParam == IDM_SAVEDSESS) {
1127 char *session = sessions[(lParam - IDM_SAVED_MIN) / 16];
1128 cl = malloc(16 + strlen(session)); /* 8, but play safe */
1129 if (!cl)
1130 cl = NULL; /* not a very important failure mode */
1131 else {
1132 sprintf(cl, "putty @%s", session);
1133 freecl = TRUE;
1134 }
1135 } else
1136 cl = NULL;
1137
1138 GetModuleFileName (NULL, b, sizeof(b)-1);
1139 si.cb = sizeof(si);
1140 si.lpReserved = NULL;
1141 si.lpDesktop = NULL;
1142 si.lpTitle = NULL;
1143 si.dwFlags = 0;
1144 si.cbReserved2 = 0;
1145 si.lpReserved2 = NULL;
1146 CreateProcess (b, cl, NULL, NULL, TRUE,
1147 NORMAL_PRIORITY_CLASS, NULL, NULL, &si, &pi);
1148
1149 if (filemap)
1150 CloseHandle(filemap);
1151 if (freecl)
1152 free(cl);
1153 }
1154 break;
1155 case IDM_RECONF:
1156 if (!do_reconfig(hwnd))
1157 break;
1158 just_reconfigged = TRUE;
1159 {
1160 int i;
1161 for (i=0; i<8; i++)
1162 if (fonts[i])
1163 DeleteObject(fonts[i]);
1164 }
1165 bold_mode = cfg.bold_colour ? BOLD_COLOURS : BOLD_FONT;
1166 und_mode = UND_FONT;
1167 init_fonts(0);
1168 sfree(logpal);
1169 /* Telnet will change local echo -> remote if the remote asks */
1170 if (cfg.protocol != PROT_TELNET)
1171 ldisc = (cfg.ldisc_term ? &ldisc_term : &ldisc_simple);
1172 if (pal)
1173 DeleteObject(pal);
1174 logpal = NULL;
1175 pal = NULL;
1176 cfgtopalette();
1177 init_palette();
1178
1179 /* Enable or disable the scroll bar, etc */
1180 {
1181 LONG nflg, flag = GetWindowLong(hwnd, GWL_STYLE);
1182
1183 nflg = flag;
1184 if (cfg.scrollbar) nflg |= WS_VSCROLL;
1185 else nflg &= ~WS_VSCROLL;
1186 if (cfg.locksize)
1187 nflg &= ~(WS_THICKFRAME|WS_MAXIMIZEBOX);
1188 else
1189 nflg |= (WS_THICKFRAME|WS_MAXIMIZEBOX);
1190
1191 if (nflg != flag)
1192 {
1193 RECT cr, wr;
1194
1195 SetWindowLong(hwnd, GWL_STYLE, nflg);
1196 SendMessage (hwnd, WM_IGNORE_SIZE, 0, 0);
1197 SetWindowPos(hwnd, NULL, 0,0,0,0,
1198 SWP_NOACTIVATE|SWP_NOCOPYBITS|
1199 SWP_NOMOVE|SWP_NOSIZE| SWP_NOZORDER|
1200 SWP_FRAMECHANGED);
1201
1202 GetWindowRect (hwnd, &wr);
1203 GetClientRect (hwnd, &cr);
1204 extra_width = wr.right - wr.left - cr.right + cr.left;
1205 extra_height = wr.bottom - wr.top - cr.bottom + cr.top;
1206 }
1207 }
1208
1209 term_size(cfg.height, cfg.width, cfg.savelines);
1210 InvalidateRect(hwnd, NULL, TRUE);
1211 SetWindowPos (hwnd, NULL, 0, 0,
1212 extra_width + font_width * cfg.width,
1213 extra_height + font_height * cfg.height,
1214 SWP_NOACTIVATE | SWP_NOCOPYBITS |
1215 SWP_NOMOVE | SWP_NOZORDER);
1216 if (IsIconic(hwnd)) {
1217 SetWindowText (hwnd,
1218 cfg.win_name_always ? window_name : icon_name);
1219 }
1220 break;
1221 case IDM_CLRSB:
1222 term_clrsb();
1223 break;
1224 case IDM_RESET:
1225 term_pwron();
1226 break;
1227 case IDM_TEL_AYT: back->special (TS_AYT); break;
1228 case IDM_TEL_BRK: back->special (TS_BRK); break;
1229 case IDM_TEL_SYNCH: back->special (TS_SYNCH); break;
1230 case IDM_TEL_EC: back->special (TS_EC); break;
1231 case IDM_TEL_EL: back->special (TS_EL); break;
1232 case IDM_TEL_GA: back->special (TS_GA); break;
1233 case IDM_TEL_NOP: back->special (TS_NOP); break;
1234 case IDM_TEL_ABORT: back->special (TS_ABORT); break;
1235 case IDM_TEL_AO: back->special (TS_AO); break;
1236 case IDM_TEL_IP: back->special (TS_IP); break;
1237 case IDM_TEL_SUSP: back->special (TS_SUSP); break;
1238 case IDM_TEL_EOR: back->special (TS_EOR); break;
1239 case IDM_TEL_EOF: back->special (TS_EOF); break;
1240 case IDM_ABOUT:
1241 showabout (hwnd);
1242 break;
1243 default:
1244 if (wParam >= IDM_SAVED_MIN && wParam <= IDM_SAVED_MAX) {
1245 SendMessage(hwnd, WM_SYSCOMMAND, IDM_SAVEDSESS, wParam);
1246 }
1247 }
1248 break;
1249
1250 #define X_POS(l) ((int)(short)LOWORD(l))
1251 #define Y_POS(l) ((int)(short)HIWORD(l))
1252
1253 #define TO_CHR_X(x) (((x)<0 ? (x)-font_width+1 : (x)) / font_width)
1254 #define TO_CHR_Y(y) (((y)<0 ? (y)-font_height+1: (y)) / font_height)
1255
1256 case WM_LBUTTONDOWN:
1257 click (MB_SELECT, TO_CHR_X(X_POS(lParam)),
1258 TO_CHR_Y(Y_POS(lParam)));
1259 SetCapture(hwnd);
1260 return 0;
1261 case WM_LBUTTONUP:
1262 term_mouse (MB_SELECT, MA_RELEASE, TO_CHR_X(X_POS(lParam)),
1263 TO_CHR_Y(Y_POS(lParam)));
1264 ReleaseCapture();
1265 return 0;
1266 case WM_MBUTTONDOWN:
1267 SetCapture(hwnd);
1268 click (cfg.mouse_is_xterm ? MB_PASTE : MB_EXTEND,
1269 TO_CHR_X(X_POS(lParam)),
1270 TO_CHR_Y(Y_POS(lParam)));
1271 return 0;
1272 case WM_MBUTTONUP:
1273 term_mouse (cfg.mouse_is_xterm ? MB_PASTE : MB_EXTEND,
1274 MA_RELEASE, TO_CHR_X(X_POS(lParam)),
1275 TO_CHR_Y(Y_POS(lParam)));
1276 ReleaseCapture();
1277 return 0;
1278 case WM_RBUTTONDOWN:
1279 SetCapture(hwnd);
1280 click (cfg.mouse_is_xterm ? MB_EXTEND : MB_PASTE,
1281 TO_CHR_X(X_POS(lParam)),
1282 TO_CHR_Y(Y_POS(lParam)));
1283 return 0;
1284 case WM_RBUTTONUP:
1285 term_mouse (cfg.mouse_is_xterm ? MB_EXTEND : MB_PASTE,
1286 MA_RELEASE, TO_CHR_X(X_POS(lParam)),
1287 TO_CHR_Y(Y_POS(lParam)));
1288 ReleaseCapture();
1289 return 0;
1290 case WM_MOUSEMOVE:
1291 /*
1292 * Add the mouse position and message time to the random
1293 * number noise.
1294 */
1295 noise_ultralight(lParam);
1296
1297 if (wParam & (MK_LBUTTON | MK_MBUTTON | MK_RBUTTON)) {
1298 Mouse_Button b;
1299 if (wParam & MK_LBUTTON)
1300 b = MB_SELECT;
1301 else if (wParam & MK_MBUTTON)
1302 b = cfg.mouse_is_xterm ? MB_PASTE : MB_EXTEND;
1303 else
1304 b = cfg.mouse_is_xterm ? MB_EXTEND : MB_PASTE;
1305 term_mouse (b, MA_DRAG, TO_CHR_X(X_POS(lParam)),
1306 TO_CHR_Y(Y_POS(lParam)));
1307 }
1308 return 0;
1309 case WM_IGNORE_CLIP:
1310 ignore_clip = wParam; /* don't panic on DESTROYCLIPBOARD */
1311 break;
1312 case WM_DESTROYCLIPBOARD:
1313 if (!ignore_clip)
1314 term_deselect();
1315 ignore_clip = FALSE;
1316 return 0;
1317 case WM_PAINT:
1318 {
1319 PAINTSTRUCT p;
1320 HideCaret(hwnd);
1321 hdc = BeginPaint (hwnd, &p);
1322 if (pal) {
1323 SelectPalette (hdc, pal, TRUE);
1324 RealizePalette (hdc);
1325 }
1326 term_paint (hdc, p.rcPaint.left, p.rcPaint.top,
1327 p.rcPaint.right, p.rcPaint.bottom);
1328 SelectObject (hdc, GetStockObject(SYSTEM_FONT));
1329 SelectObject (hdc, GetStockObject(WHITE_PEN));
1330 EndPaint (hwnd, &p);
1331 ShowCaret(hwnd);
1332 }
1333 return 0;
1334 case WM_NETEVENT:
1335 /* Notice we can get multiple netevents, FD_READ, FD_WRITE etc
1336 * but the only one that's likely to try to overload us is FD_READ.
1337 * This means buffering just one is fine.
1338 */
1339 if (pending_netevent)
1340 enact_pending_netevent();
1341
1342 pending_netevent = TRUE;
1343 pend_netevent_wParam=wParam;
1344 pend_netevent_lParam=lParam;
1345 time(&last_movement);
1346 return 0;
1347 case WM_SETFOCUS:
1348 has_focus = TRUE;
1349 CreateCaret(hwnd, caretbm, 0, 0);
1350 ShowCaret(hwnd);
1351 term_out();
1352 term_update();
1353 break;
1354 case WM_KILLFOCUS:
1355 has_focus = FALSE;
1356 DestroyCaret();
1357 term_out();
1358 term_update();
1359 break;
1360 case WM_IGNORE_SIZE:
1361 ignore_size = TRUE; /* don't panic on next WM_SIZE msg */
1362 break;
1363 case WM_ENTERSIZEMOVE:
1364 EnableSizeTip(1);
1365 resizing = TRUE;
1366 break;
1367 case WM_EXITSIZEMOVE:
1368 EnableSizeTip(0);
1369 resizing = FALSE;
1370 back->size();
1371 break;
1372 case WM_SIZING:
1373 {
1374 int width, height, w, h, ew, eh;
1375 LPRECT r = (LPRECT)lParam;
1376
1377 width = r->right - r->left - extra_width;
1378 height = r->bottom - r->top - extra_height;
1379 w = (width + font_width/2) / font_width; if (w < 1) w = 1;
1380 h = (height + font_height/2) / font_height; if (h < 1) h = 1;
1381 UpdateSizeTip(hwnd, w, h);
1382 ew = width - w * font_width;
1383 eh = height - h * font_height;
1384 if (ew != 0) {
1385 if (wParam == WMSZ_LEFT ||
1386 wParam == WMSZ_BOTTOMLEFT ||
1387 wParam == WMSZ_TOPLEFT)
1388 r->left += ew;
1389 else
1390 r->right -= ew;
1391 }
1392 if (eh != 0) {
1393 if (wParam == WMSZ_TOP ||
1394 wParam == WMSZ_TOPRIGHT ||
1395 wParam == WMSZ_TOPLEFT)
1396 r->top += eh;
1397 else
1398 r->bottom -= eh;
1399 }
1400 if (ew || eh)
1401 return 1;
1402 else
1403 return 0;
1404 }
1405 /* break; (never reached) */
1406 case WM_SIZE:
1407 if (wParam == SIZE_MINIMIZED) {
1408 SetWindowText (hwnd,
1409 cfg.win_name_always ? window_name : icon_name);
1410 break;
1411 }
1412 if (wParam == SIZE_RESTORED || wParam == SIZE_MAXIMIZED)
1413 SetWindowText (hwnd, window_name);
1414 if (!ignore_size) {
1415 int width, height, w, h;
1416 #if 0 /* we have fixed this using WM_SIZING now */
1417 int ew, eh;
1418 #endif
1419
1420 width = LOWORD(lParam);
1421 height = HIWORD(lParam);
1422 w = width / font_width; if (w < 1) w = 1;
1423 h = height / font_height; if (h < 1) h = 1;
1424 #if 0 /* we have fixed this using WM_SIZING now */
1425 ew = width - w * font_width;
1426 eh = height - h * font_height;
1427 if (ew != 0 || eh != 0) {
1428 RECT r;
1429 GetWindowRect (hwnd, &r);
1430 SendMessage (hwnd, WM_IGNORE_SIZE, 0, 0);
1431 SetWindowPos (hwnd, NULL, 0, 0,
1432 r.right - r.left - ew, r.bottom - r.top - eh,
1433 SWP_NOACTIVATE | SWP_NOMOVE | SWP_NOZORDER);
1434 }
1435 #endif
1436 if (w != cols || h != rows || just_reconfigged) {
1437 term_invalidate();
1438 term_size (h, w, cfg.savelines);
1439 /*
1440 * Don't call back->size in mid-resize. (To prevent
1441 * massive numbers of resize events getting sent
1442 * down the connection during an NT opaque drag.)
1443 */
1444 if (!resizing)
1445 back->size();
1446 just_reconfigged = FALSE;
1447 }
1448 }
1449 ignore_size = FALSE;
1450 return 0;
1451 case WM_VSCROLL:
1452 switch (LOWORD(wParam)) {
1453 case SB_BOTTOM: term_scroll(-1, 0); break;
1454 case SB_TOP: term_scroll(+1, 0); break;
1455 case SB_LINEDOWN: term_scroll (0, +1); break;
1456 case SB_LINEUP: term_scroll (0, -1); break;
1457 case SB_PAGEDOWN: term_scroll (0, +rows/2); break;
1458 case SB_PAGEUP: term_scroll (0, -rows/2); break;
1459 case SB_THUMBPOSITION: case SB_THUMBTRACK:
1460 term_scroll (1, HIWORD(wParam)); break;
1461 }
1462 break;
1463 case WM_PALETTECHANGED:
1464 if ((HWND) wParam != hwnd && pal != NULL) {
1465 HDC hdc = get_ctx();
1466 if (hdc) {
1467 if (RealizePalette (hdc) > 0)
1468 UpdateColors (hdc);
1469 free_ctx (hdc);
1470 }
1471 }
1472 break;
1473 case WM_QUERYNEWPALETTE:
1474 if (pal != NULL) {
1475 HDC hdc = get_ctx();
1476 if (hdc) {
1477 if (RealizePalette (hdc) > 0)
1478 UpdateColors (hdc);
1479 free_ctx (hdc);
1480 return TRUE;
1481 }
1482 }
1483 return FALSE;
1484 case WM_KEYDOWN:
1485 case WM_SYSKEYDOWN:
1486 case WM_KEYUP:
1487 case WM_SYSKEYUP:
1488 /*
1489 * Add the scan code and keypress timing to the random
1490 * number noise.
1491 */
1492 noise_ultralight(lParam);
1493
1494 /*
1495 * We don't do TranslateMessage since it disassociates the
1496 * resulting CHAR message from the KEYDOWN that sparked it,
1497 * which we occasionally don't want. Instead, we process
1498 * KEYDOWN, and call the Win32 translator functions so that
1499 * we get the translations under _our_ control.
1500 */
1501 {
1502 unsigned char buf[20];
1503 int len;
1504
1505 if (wParam==VK_PROCESSKEY) {
1506 MSG m;
1507 m.hwnd = hwnd;
1508 m.message = WM_KEYDOWN;
1509 m.wParam = wParam;
1510 m.lParam = lParam & 0xdfff;
1511 TranslateMessage(&m);
1512 } else {
1513 len = TranslateKey (message, wParam, lParam, buf);
1514 if (len == -1)
1515 return DefWindowProc (hwnd, message, wParam, lParam);
1516 ldisc->send (buf, len);
1517 }
1518 }
1519 return 0;
1520 case WM_IME_CHAR:
1521 {
1522 unsigned char buf[2];
1523
1524 buf[1] = wParam;
1525 buf[0] = wParam >> 8;
1526 ldisc->send (buf, 2);
1527 }
1528 case WM_CHAR:
1529 case WM_SYSCHAR:
1530 /*
1531 * Nevertheless, we are prepared to deal with WM_CHAR
1532 * messages, should they crop up. So if someone wants to
1533 * post the things to us as part of a macro manoeuvre,
1534 * we're ready to cope.
1535 */
1536 {
1537 char c = xlat_kbd2tty((unsigned char)wParam);
1538 ldisc->send (&c, 1);
1539 }
1540 return 0;
1541 }
1542
1543 return DefWindowProc (hwnd, message, wParam, lParam);
1544 }
1545
1546 /*
1547 * Move the system caret. (We maintain one, even though it's
1548 * invisible, for the benefit of blind people: apparently some
1549 * helper software tracks the system caret, so we should arrange to
1550 * have one.)
1551 */
1552 void sys_cursor(int x, int y) {
1553 SetCaretPos(x * font_width, y * font_height);
1554 }
1555
1556 /*
1557 * Draw a line of text in the window, at given character
1558 * coordinates, in given attributes.
1559 *
1560 * We are allowed to fiddle with the contents of `text'.
1561 */
1562 void do_text (Context ctx, int x, int y, char *text, int len,
1563 unsigned long attr, int lattr) {
1564 COLORREF fg, bg, t;
1565 int nfg, nbg, nfont;
1566 HDC hdc = ctx;
1567 RECT line_box;
1568 int force_manual_underline = 0;
1569 int fnt_width = font_width*(1+(lattr!=LATTR_NORM));
1570 static int *IpDx = 0, IpDxLEN = 0;;
1571
1572 if (len>IpDxLEN || IpDx[0] != fnt_width) {
1573 int i;
1574 if (len>IpDxLEN) {
1575 sfree(IpDx);
1576 IpDx = smalloc((len+16)*sizeof(int));
1577 IpDxLEN = (len+16);
1578 }
1579 for(i=0; i<IpDxLEN; i++)
1580 IpDx[i] = fnt_width;
1581 }
1582
1583 x *= fnt_width;
1584 y *= font_height;
1585
1586 if (attr & ATTR_ACTCURS) {
1587 attr &= (bold_mode == BOLD_COLOURS ? 0x300200 : 0x300300);
1588 attr ^= ATTR_CUR_XOR;
1589 }
1590
1591 nfont = 0;
1592 if (cfg.vtmode == VT_OEMONLY)
1593 nfont |= FONT_OEM;
1594
1595 /*
1596 * Map high-half characters in order to approximate ISO using
1597 * OEM character set. No characters are missing if the OEM codepage
1598 * is CP850.
1599 */
1600 if (nfont & FONT_OEM) {
1601 int i;
1602 for (i=0; i<len; i++)
1603 if (text[i] >= '\xA0' && text[i] <= '\xFF') {
1604 #if 0
1605 /* This is CP850 ... perfect translation */
1606 static const char oemhighhalf[] =
1607 "\x20\xAD\xBD\x9C\xCF\xBE\xDD\xF5" /* A0-A7 */
1608 "\xF9\xB8\xA6\xAE\xAA\xF0\xA9\xEE" /* A8-AF */
1609 "\xF8\xF1\xFD\xFC\xEF\xE6\xF4\xFA" /* B0-B7 */
1610 "\xF7\xFB\xA7\xAF\xAC\xAB\xF3\xA8" /* B8-BF */
1611 "\xB7\xB5\xB6\xC7\x8E\x8F\x92\x80" /* C0-C7 */
1612 "\xD4\x90\xD2\xD3\xDE\xD6\xD7\xD8" /* C8-CF */
1613 "\xD1\xA5\xE3\xE0\xE2\xE5\x99\x9E" /* D0-D7 */
1614 "\x9D\xEB\xE9\xEA\x9A\xED\xE8\xE1" /* D8-DF */
1615 "\x85\xA0\x83\xC6\x84\x86\x91\x87" /* E0-E7 */
1616 "\x8A\x82\x88\x89\x8D\xA1\x8C\x8B" /* E8-EF */
1617 "\xD0\xA4\x95\xA2\x93\xE4\x94\xF6" /* F0-F7 */
1618 "\x9B\x97\xA3\x96\x81\xEC\xE7\x98" /* F8-FF */
1619 ;
1620 #endif
1621 /* This is CP437 ... junk translation */
1622 static const unsigned char oemhighhalf[] = {
1623 0xff, 0xad, 0x9b, 0x9c, 0x6f, 0x9d, 0x7c, 0x15,
1624 0x22, 0x43, 0xa6, 0xae, 0xaa, 0x2d, 0x52, 0xc4,
1625 0xf8, 0xf1, 0xfd, 0x33, 0x27, 0xe6, 0x14, 0xfa,
1626 0x2c, 0x31, 0xa7, 0xaf, 0xac, 0xab, 0x2f, 0xa8,
1627 0x41, 0x41, 0x41, 0x41, 0x8e, 0x8f, 0x92, 0x80,
1628 0x45, 0x90, 0x45, 0x45, 0x49, 0x49, 0x49, 0x49,
1629 0x44, 0xa5, 0x4f, 0x4f, 0x4f, 0x4f, 0x99, 0x78,
1630 0xed, 0x55, 0x55, 0x55, 0x9a, 0x59, 0x50, 0xe1,
1631 0x85, 0xa0, 0x83, 0x61, 0x84, 0x86, 0x91, 0x87,
1632 0x8a, 0x82, 0x88, 0x89, 0x8d, 0xa1, 0x8c, 0x8b,
1633 0x0b, 0xa4, 0x95, 0xa2, 0x93, 0x6f, 0x94, 0xf6,
1634 0xed, 0x97, 0xa3, 0x96, 0x81, 0x79, 0x70, 0x98
1635 };
1636
1637 text[i] = oemhighhalf[(unsigned char)text[i] - 0xA0];
1638 }
1639 }
1640
1641 if (attr & ATTR_LINEDRW) {
1642 int i;
1643 /* ISO 8859-1 */
1644 static const char poorman[] =
1645 "*#****\xB0\xB1**+++++-----++++|****\xA3\xB7";
1646
1647 /* CP437 */
1648 static const char oemmap_437[] =
1649 "\x04\xB1****\xF8\xF1**\xD9\xBF\xDA\xC0\xC5"
1650 "\xC4\xC4\xC4\xC4\xC4\xC3\xB4\xC1\xC2\xB3\xF3\xF2\xE3*\x9C\xFA";
1651
1652 /* CP850 */
1653 static const char oemmap_850[] =
1654 "\x04\xB1****\xF8\xF1**\xD9\xBF\xDA\xC0\xC5"
1655 "\xC4\xC4\xC4\xC4\xC4\xC3\xB4\xC1\xC2\xB3****\x9C\xFA";
1656
1657 /* Poor windows font ... eg: windows courier */
1658 static const char oemmap[] =
1659 "*\xB1****\xF8\xF1**\xD9\xBF\xDA\xC0\xC5"
1660 "\xC4\xC4\xC4\xC4\xC4\xC3\xB4\xC1\xC2\xB3****\x9C\xFA";
1661
1662 /*
1663 * Line drawing mapping: map ` thru ~ (0x60 thru 0x7E) to
1664 * VT100 line drawing chars; everything else stays normal.
1665 *
1666 * Actually '_' maps to space too, but that's done before.
1667 */
1668 switch (cfg.vtmode) {
1669 case VT_XWINDOWS:
1670 for (i=0; i<len; i++)
1671 if (text[i] >= '\x60' && text[i] <= '\x7E')
1672 text[i] += '\x01' - '\x60';
1673 break;
1674 case VT_OEMANSI:
1675 /* Make sure we actually have an OEM font */
1676 if (fonts[nfont|FONT_OEM]) {
1677 case VT_OEMONLY:
1678 nfont |= FONT_OEM;
1679 for (i=0; i<len; i++)
1680 if (text[i] >= '\x60' && text[i] <= '\x7E')
1681 text[i] = oemmap[(unsigned char)text[i] - 0x60];
1682 break;
1683 }
1684 case VT_POORMAN:
1685 for (i=0; i<len; i++)
1686 if (text[i] >= '\x60' && text[i] <= '\x7E')
1687 text[i] = poorman[(unsigned char)text[i] - 0x60];
1688 break;
1689 }
1690 }
1691
1692 nfg = 2 * ((attr & ATTR_FGMASK) >> ATTR_FGSHIFT);
1693 nbg = 2 * ((attr & ATTR_BGMASK) >> ATTR_BGSHIFT);
1694 if (bold_mode == BOLD_FONT && (attr & ATTR_BOLD))
1695 nfont |= FONT_BOLD;
1696 if (und_mode == UND_FONT && (attr & ATTR_UNDER))
1697 nfont |= FONT_UNDERLINE;
1698 if (!fonts[nfont])
1699 {
1700 if (nfont&FONT_UNDERLINE)
1701 force_manual_underline = 1;
1702 /* Don't do the same for manual bold, it could be bad news. */
1703
1704 nfont &= ~(FONT_BOLD|FONT_UNDERLINE);
1705 }
1706 if (font_needs_hand_underlining && (attr & ATTR_UNDER))
1707 force_manual_underline = 1;
1708 if (attr & ATTR_REVERSE) {
1709 t = nfg; nfg = nbg; nbg = t;
1710 }
1711 if (bold_mode == BOLD_COLOURS && (attr & ATTR_BOLD))
1712 nfg++;
1713 if (bold_mode == BOLD_COLOURS && (attr & ATTR_BLINK))
1714 nbg++;
1715 fg = colours[nfg];
1716 bg = colours[nbg];
1717 SelectObject (hdc, fonts[nfont]);
1718 SetTextColor (hdc, fg);
1719 SetBkColor (hdc, bg);
1720 SetBkMode (hdc, OPAQUE);
1721 line_box.left = x;
1722 line_box.top = y;
1723 line_box.right = x+fnt_width*len;
1724 line_box.bottom = y+font_height;
1725 ExtTextOut (hdc, x, y, ETO_CLIPPED|ETO_OPAQUE, &line_box, text, len, IpDx);
1726 if (bold_mode == BOLD_SHADOW && (attr & ATTR_BOLD)) {
1727 SetBkMode (hdc, TRANSPARENT);
1728
1729 /* GRR: This draws the character outside it's box and can leave
1730 * 'droppings' even with the clip box! I suppose I could loop it
1731 * one character at a time ... yuk.
1732 *
1733 * Or ... I could do a test print with "W", and use +1 or -1 for this
1734 * shift depending on if the leftmost column is blank...
1735 */
1736 ExtTextOut (hdc, x-1, y, ETO_CLIPPED, &line_box, text, len, IpDx);
1737 }
1738 if (force_manual_underline ||
1739 (und_mode == UND_LINE && (attr & ATTR_UNDER))) {
1740 HPEN oldpen;
1741 oldpen = SelectObject (hdc, CreatePen(PS_SOLID, 0, fg));
1742 MoveToEx (hdc, x, y+descent, NULL);
1743 LineTo (hdc, x+len*fnt_width, y+descent);
1744 oldpen = SelectObject (hdc, oldpen);
1745 DeleteObject (oldpen);
1746 }
1747 if (attr & ATTR_PASCURS) {
1748 POINT pts[5];
1749 HPEN oldpen;
1750 pts[0].x = pts[1].x = pts[4].x = x;
1751 pts[2].x = pts[3].x = x+fnt_width-1;
1752 pts[0].y = pts[3].y = pts[4].y = y;
1753 pts[1].y = pts[2].y = y+font_height-1;
1754 oldpen = SelectObject (hdc, CreatePen(PS_SOLID, 0, colours[23]));
1755 Polyline (hdc, pts, 5);
1756 oldpen = SelectObject (hdc, oldpen);
1757 DeleteObject (oldpen);
1758 }
1759 }
1760
1761 static int check_compose(int first, int second) {
1762
1763 static char * composetbl[] = {
1764 "++#", "AA@", "(([", "//\\", "))]", "(-{", "-)}", "/^|", "!!¡", "C/¢",
1765 "C|¢", "L-£", "L=£", "XO¤", "X0¤", "Y-¥", "Y=¥", "||¦", "SO§", "S!§",
1766 "S0§", "\"\"¨", "CO©", "C0©", "A_ª", "<<«", ",-¬", "--­", "RO®",
1767 "-^¯", "0^°", "+-±", "2^²", "3^³", "''´", "/Uµ", "P!¶", ".^·", ",,¸",
1768 "1^¹", "O_º", ">>»", "14¼", "12½", "34¾", "??¿", "`AÀ", "'AÁ", "^AÂ",
1769 "~AÃ", "\"AÄ", "*AÅ", "AEÆ", ",CÇ", "`EÈ", "'EÉ", "^EÊ", "\"EË",
1770 "`IÌ", "'IÍ", "^IÎ", "\"IÏ", "-DÐ", "~NÑ", "`OÒ", "'OÓ", "^OÔ",
1771 "~OÕ", "\"OÖ", "XX×", "/OØ", "`UÙ", "'UÚ", "^UÛ", "\"UÜ", "'YÝ",
1772 "HTÞ", "ssß", "`aà", "'aá", "^aâ", "~aã", "\"aä", "*aå", "aeæ", ",cç",
1773 "`eè", "'eé", "^eê", "\"eë", "`iì", "'ií", "^iî", "\"iï", "-dð", "~nñ",
1774 "`oò", "'oó", "^oô", "~oõ", "\"oö", ":-÷", "o/ø", "`uù", "'uú", "^uû",
1775 "\"uü", "'yý", "htþ", "\"yÿ",
1776 0};
1777
1778 char ** c;
1779 static int recurse = 0;
1780 int nc = -1;
1781
1782 for(c=composetbl; *c; c++) {
1783 if( (*c)[0] == first && (*c)[1] == second)
1784 {
1785 return (*c)[2] & 0xFF;
1786 }
1787 }
1788
1789 if(recurse==0)
1790 {
1791 recurse=1;
1792 nc = check_compose(second, first);
1793 if(nc == -1)
1794 nc = check_compose(toupper(first), toupper(second));
1795 if(nc == -1)
1796 nc = check_compose(toupper(second), toupper(first));
1797 recurse=0;
1798 }
1799 return nc;
1800 }
1801
1802
1803 /*
1804 * Translate a WM_(SYS)?KEY(UP|DOWN) message into a string of ASCII
1805 * codes. Returns number of bytes used or zero to drop the message
1806 * or -1 to forward the message to windows.
1807 */
1808 static int TranslateKey(UINT message, WPARAM wParam, LPARAM lParam,
1809 unsigned char *output) {
1810 BYTE keystate[256];
1811 int scan, left_alt = 0, key_down, shift_state;
1812 int r, i, code;
1813 unsigned char * p = output;
1814
1815 static WORD keys[3];
1816 static int compose_state = 0;
1817 static int compose_char = 0;
1818 static WPARAM compose_key = 0;
1819
1820 r = GetKeyboardState(keystate);
1821 if (!r) memset(keystate, 0, sizeof(keystate));
1822 else
1823 {
1824 #if 0
1825 { /* Tell us all about key events */
1826 static BYTE oldstate[256];
1827 static int first = 1;
1828 static int scan;
1829 int ch;
1830 if(first) memcpy(oldstate, keystate, sizeof(oldstate));
1831 first=0;
1832
1833 if ((HIWORD(lParam)&(KF_UP|KF_REPEAT))==KF_REPEAT) {
1834 debug(("+"));
1835 } else if ((HIWORD(lParam)&KF_UP) && scan==(HIWORD(lParam) & 0xFF) ) {
1836 debug((". U"));
1837 } else {
1838 debug((".\n"));
1839 if (wParam >= VK_F1 && wParam <= VK_F20 )
1840 debug(("K_F%d", wParam+1-VK_F1));
1841 else switch(wParam)
1842 {
1843 case VK_SHIFT: debug(("SHIFT")); break;
1844 case VK_CONTROL: debug(("CTRL")); break;
1845 case VK_MENU: debug(("ALT")); break;
1846 default: debug(("VK_%02x", wParam));
1847 }
1848 if(message == WM_SYSKEYDOWN || message == WM_SYSKEYUP)
1849 debug(("*"));
1850 debug((", S%02x", scan=(HIWORD(lParam) & 0xFF) ));
1851
1852 ch = MapVirtualKey(wParam, 2);
1853 if (ch>=' ' && ch<='~') debug((", '%c'", ch));
1854 else if (ch) debug((", $%02x", ch));
1855
1856 if (keys[0]) debug((", KB0=%02x", keys[0]));
1857 if (keys[1]) debug((", KB1=%02x", keys[1]));
1858 if (keys[2]) debug((", KB2=%02x", keys[2]));
1859
1860 if ( (keystate[VK_SHIFT]&0x80)!=0) debug((", S"));
1861 if ( (keystate[VK_CONTROL]&0x80)!=0) debug((", C"));
1862 if ( (HIWORD(lParam)&KF_EXTENDED) ) debug((", E"));
1863 if ( (HIWORD(lParam)&KF_UP) ) debug((", U"));
1864 }
1865
1866 if ((HIWORD(lParam)&(KF_UP|KF_REPEAT))==KF_REPEAT)
1867 ;
1868 else if ( (HIWORD(lParam)&KF_UP) )
1869 oldstate[wParam&0xFF] ^= 0x80;
1870 else
1871 oldstate[wParam&0xFF] ^= 0x81;
1872
1873 for(ch=0; ch<256; ch++)
1874 if (oldstate[ch] != keystate[ch])
1875 debug((", M%02x=%02x", ch, keystate[ch]));
1876
1877 memcpy(oldstate, keystate, sizeof(oldstate));
1878 }
1879 #endif
1880
1881 /* Note if AltGr was pressed and if it was used as a compose key */
1882 if (cfg.compose_key) {
1883 if (wParam == VK_MENU && (HIWORD(lParam)&KF_EXTENDED))
1884 {
1885 keystate[VK_RMENU] = keystate[VK_MENU];
1886 if (!compose_state) compose_key = wParam;
1887 }
1888 if (wParam == VK_APPS && !compose_state)
1889 compose_key = wParam;
1890
1891 if (wParam == compose_key)
1892 {
1893 if (compose_state == 0 && (HIWORD(lParam)&(KF_UP|KF_REPEAT))==0)
1894 compose_state = 1;
1895 else if (compose_state == 1 && (HIWORD(lParam)&KF_UP))
1896 compose_state = 2;
1897 else
1898 compose_state = 0;
1899 }
1900 else if (compose_state==1 && wParam != VK_CONTROL)
1901 compose_state = 0;
1902 } else
1903 compose_state = 0;
1904
1905 /* Nastyness with NUMLock - Shift-NUMLock is left alone though */
1906 if ( (cfg.funky_type == 3 || (cfg.funky_type <= 1 && app_keypad_keys))
1907 && wParam==VK_NUMLOCK && !(keystate[VK_SHIFT]&0x80)) {
1908
1909 wParam = VK_EXECUTE;
1910
1911 /* UnToggle NUMLock */
1912 if ((HIWORD(lParam)&(KF_UP|KF_REPEAT))==0)
1913 keystate[VK_NUMLOCK] ^= 1;
1914 }
1915
1916 /* And write back the 'adjusted' state */
1917 SetKeyboardState (keystate);
1918 }
1919
1920 /* Disable Auto repeat if required */
1921 if (repeat_off && (HIWORD(lParam)&(KF_UP|KF_REPEAT))==KF_REPEAT)
1922 return 0;
1923
1924 if ((HIWORD(lParam)&KF_ALTDOWN) && (keystate[VK_RMENU]&0x80) == 0)
1925 left_alt = 1;
1926
1927 key_down = ((HIWORD(lParam)&KF_UP)==0);
1928
1929 /* Make sure Ctrl-ALT is not the same as AltGr for ToAscii */
1930 if (left_alt && (keystate[VK_CONTROL]&0x80))
1931 keystate[VK_MENU] = 0;
1932
1933 scan = (HIWORD(lParam) & (KF_UP | KF_EXTENDED | 0xFF));
1934 shift_state = ((keystate[VK_SHIFT]&0x80)!=0)
1935 + ((keystate[VK_CONTROL]&0x80)!=0)*2;
1936
1937 /*
1938 * Record that we pressed key so the scroll window can be reset, but
1939 * be careful to avoid Shift-UP/Down
1940 */
1941 if( wParam != VK_SHIFT && wParam != VK_PRIOR && wParam != VK_NEXT ) {
1942 seen_key_event = 1;
1943 }
1944
1945 /* Make sure we're not pasting */
1946 if (key_down) term_nopaste();
1947
1948 if (compose_state>1 && left_alt) compose_state = 0;
1949
1950 /* Sanitize the number pad if not using a PC NumPad */
1951 if( left_alt || (app_keypad_keys && cfg.funky_type != 2)
1952 || cfg.funky_type == 3 || cfg.nethack_keypad || compose_state )
1953 {
1954 if ((HIWORD(lParam)&KF_EXTENDED) == 0)
1955 {
1956 int nParam = 0;
1957 switch(wParam)
1958 {
1959 case VK_INSERT: nParam = VK_NUMPAD0; break;
1960 case VK_END: nParam = VK_NUMPAD1; break;
1961 case VK_DOWN: nParam = VK_NUMPAD2; break;
1962 case VK_NEXT: nParam = VK_NUMPAD3; break;
1963 case VK_LEFT: nParam = VK_NUMPAD4; break;
1964 case VK_CLEAR: nParam = VK_NUMPAD5; break;
1965 case VK_RIGHT: nParam = VK_NUMPAD6; break;
1966 case VK_HOME: nParam = VK_NUMPAD7; break;
1967 case VK_UP: nParam = VK_NUMPAD8; break;
1968 case VK_PRIOR: nParam = VK_NUMPAD9; break;
1969 case VK_DELETE: nParam = VK_DECIMAL; break;
1970 }
1971 if (nParam)
1972 {
1973 if (keystate[VK_NUMLOCK]&1) shift_state |= 1;
1974 wParam = nParam;
1975 }
1976 }
1977 }
1978
1979 /* If a key is pressed and AltGr is not active */
1980 if (key_down && (keystate[VK_RMENU]&0x80) == 0 && !compose_state)
1981 {
1982 /* Okay, prepare for most alts then ...*/
1983 if (left_alt) *p++ = '\033';
1984
1985 /* Lets see if it's a pattern we know all about ... */
1986 if (wParam == VK_PRIOR && shift_state == 1) {
1987 SendMessage (hwnd, WM_VSCROLL, SB_PAGEUP, 0);
1988 return 0;
1989 }
1990 if (wParam == VK_NEXT && shift_state == 1) {
1991 SendMessage (hwnd, WM_VSCROLL, SB_PAGEDOWN, 0);
1992 return 0;
1993 }
1994 if (wParam == VK_INSERT && shift_state == 1) {
1995 term_mouse (MB_PASTE, MA_CLICK, 0, 0);
1996 term_mouse (MB_PASTE, MA_RELEASE, 0, 0);
1997 return 0;
1998 }
1999 if (left_alt && wParam == VK_F4 && cfg.alt_f4) {
2000 return -1;
2001 }
2002 if (left_alt && wParam == VK_SPACE && cfg.alt_space) {
2003
2004 SendMessage (hwnd, WM_SYSCOMMAND, SC_KEYMENU, 0);
2005 return -1;
2006 }
2007 /* Control-Numlock for app-keypad mode switch */
2008 if (wParam == VK_PAUSE && shift_state == 2) {
2009 app_keypad_keys ^= 1;
2010 return 0;
2011 }
2012
2013 /* Nethack keypad */
2014 if (cfg.nethack_keypad && !left_alt) {
2015 switch(wParam) {
2016 case VK_NUMPAD1: *p++ = shift_state ? 'B': 'b'; return p-output;
2017 case VK_NUMPAD2: *p++ = shift_state ? 'J': 'j'; return p-output;
2018 case VK_NUMPAD3: *p++ = shift_state ? 'N': 'n'; return p-output;
2019 case VK_NUMPAD4: *p++ = shift_state ? 'H': 'h'; return p-output;
2020 case VK_NUMPAD5: *p++ = shift_state ? '.': '.'; return p-output;
2021 case VK_NUMPAD6: *p++ = shift_state ? 'L': 'l'; return p-output;
2022 case VK_NUMPAD7: *p++ = shift_state ? 'Y': 'y'; return p-output;
2023 case VK_NUMPAD8: *p++ = shift_state ? 'K': 'k'; return p-output;
2024 case VK_NUMPAD9: *p++ = shift_state ? 'U': 'u'; return p-output;
2025 }
2026 }
2027
2028 /* Application Keypad */
2029 if (!left_alt) {
2030 int xkey = 0;
2031
2032 if ( cfg.funky_type == 3 ||
2033 ( cfg.funky_type <= 1 && app_keypad_keys)) switch(wParam) {
2034 case VK_EXECUTE: xkey = 'P'; break;
2035 case VK_DIVIDE: xkey = 'Q'; break;
2036 case VK_MULTIPLY:xkey = 'R'; break;
2037 case VK_SUBTRACT:xkey = 'S'; break;
2038 }
2039 if(app_keypad_keys) switch(wParam) {
2040 case VK_NUMPAD0: xkey = 'p'; break;
2041 case VK_NUMPAD1: xkey = 'q'; break;
2042 case VK_NUMPAD2: xkey = 'r'; break;
2043 case VK_NUMPAD3: xkey = 's'; break;
2044 case VK_NUMPAD4: xkey = 't'; break;
2045 case VK_NUMPAD5: xkey = 'u'; break;
2046 case VK_NUMPAD6: xkey = 'v'; break;
2047 case VK_NUMPAD7: xkey = 'w'; break;
2048 case VK_NUMPAD8: xkey = 'x'; break;
2049 case VK_NUMPAD9: xkey = 'y'; break;
2050
2051 case VK_DECIMAL: xkey = 'n'; break;
2052 case VK_ADD: if(cfg.funky_type==2) {
2053 if(shift_state) xkey = 'l';
2054 else xkey = 'k';
2055 } else if(shift_state) xkey = 'm';
2056 else xkey = 'l';
2057 break;
2058
2059 case VK_DIVIDE: if(cfg.funky_type==2) xkey = 'o'; break;
2060 case VK_MULTIPLY:if(cfg.funky_type==2) xkey = 'j'; break;
2061 case VK_SUBTRACT:if(cfg.funky_type==2) xkey = 'm'; break;
2062
2063 case VK_RETURN:
2064 if (HIWORD(lParam)&KF_EXTENDED)
2065 xkey = 'M';
2066 break;
2067 }
2068 if(xkey)
2069 {
2070 if (vt52_mode)
2071 {
2072 if (xkey>='P' && xkey<='S')
2073 p += sprintf((char *)p, "\x1B%c", xkey);
2074 else
2075 p += sprintf((char *)p, "\x1B?%c", xkey);
2076 }
2077 else
2078 p += sprintf((char *)p, "\x1BO%c", xkey);
2079 return p - output;
2080 }
2081 }
2082
2083 if (wParam == VK_BACK && shift_state == 0 ) /* Backspace */
2084 {
2085 *p++ = (cfg.bksp_is_delete ? 0x7F : 0x08);
2086 return p-output;
2087 }
2088 if (wParam == VK_TAB && shift_state == 1 ) /* Shift tab */
2089 {
2090 *p++ = 0x1B; *p++ = '['; *p++ = 'Z'; return p - output;
2091 }
2092 if (wParam == VK_SPACE && shift_state == 2 ) /* Ctrl-Space */
2093 {
2094 *p++ = 0; return p - output;
2095 }
2096 if (wParam == VK_SPACE && shift_state == 3 ) /* Ctrl-Shift-Space */
2097 {
2098 *p++ = 160; return p - output;
2099 }
2100 if (wParam == VK_CANCEL && shift_state == 2 ) /* Ctrl-Break */
2101 {
2102 *p++ = 3; return p - output;
2103 }
2104 /* Control-2 to Control-8 are special */
2105 if (shift_state == 2 && wParam >= '2' && wParam <= '8')
2106 {
2107 *p++ = "\000\033\034\035\036\037\177"[wParam-'2'];
2108 return p - output;
2109 }
2110 if (shift_state == 2 && wParam == 0xBD) {
2111 *p++ = 0x1F;
2112 return p - output;
2113 }
2114 if (shift_state == 2 && wParam == 0xDF) {
2115 *p++ = 0x1C;
2116 return p - output;
2117 }
2118 if (shift_state == 0 && wParam == VK_RETURN && cr_lf_return) {
2119 *p++ = '\r'; *p++ = '\n';
2120 return p - output;
2121 }
2122
2123 /*
2124 * Next, all the keys that do tilde codes. (ESC '[' nn '~',
2125 * for integer decimal nn.)
2126 *
2127 * We also deal with the weird ones here. Linux VCs replace F1
2128 * to F5 by ESC [ [ A to ESC [ [ E. rxvt doesn't do _that_, but
2129 * does replace Home and End (1~ and 4~) by ESC [ H and ESC O w
2130 * respectively.
2131 */
2132 code = 0;
2133 switch (wParam) {
2134 case VK_F1: code = (keystate[VK_SHIFT] & 0x80 ? 23 : 11); break;
2135 case VK_F2: code = (keystate[VK_SHIFT] & 0x80 ? 24 : 12); break;
2136 case VK_F3: code = (keystate[VK_SHIFT] & 0x80 ? 25 : 13); break;
2137 case VK_F4: code = (keystate[VK_SHIFT] & 0x80 ? 26 : 14); break;
2138 case VK_F5: code = (keystate[VK_SHIFT] & 0x80 ? 28 : 15); break;
2139 case VK_F6: code = (keystate[VK_SHIFT] & 0x80 ? 29 : 17); break;
2140 case VK_F7: code = (keystate[VK_SHIFT] & 0x80 ? 31 : 18); break;
2141 case VK_F8: code = (keystate[VK_SHIFT] & 0x80 ? 32 : 19); break;
2142 case VK_F9: code = (keystate[VK_SHIFT] & 0x80 ? 33 : 20); break;
2143 case VK_F10: code = (keystate[VK_SHIFT] & 0x80 ? 34 : 21); break;
2144 case VK_F11: code = 23; break;
2145 case VK_F12: code = 24; break;
2146 case VK_F13: code = 25; break;
2147 case VK_F14: code = 26; break;
2148 case VK_F15: code = 28; break;
2149 case VK_F16: code = 29; break;
2150 case VK_F17: code = 31; break;
2151 case VK_F18: code = 32; break;
2152 case VK_F19: code = 33; break;
2153 case VK_F20: code = 34; break;
2154 case VK_HOME: code = 1; break;
2155 case VK_INSERT: code = 2; break;
2156 case VK_DELETE: code = 3; break;
2157 case VK_END: code = 4; break;
2158 case VK_PRIOR: code = 5; break;
2159 case VK_NEXT: code = 6; break;
2160 }
2161 /* Reorder edit keys to physical order */
2162 if (cfg.funky_type == 3 && code <= 6 ) code = "\0\2\1\4\5\3\6"[code];
2163
2164 if (cfg.funky_type == 1 && code >= 11 && code <= 15) {
2165 p += sprintf((char *)p, "\x1B[[%c", code + 'A' - 11);
2166 return p - output;
2167 }
2168 if (cfg.funky_type == 2 && code >= 11 && code <= 14) {
2169 if (vt52_mode)
2170 p += sprintf((char *)p, "\x1B%c", code + 'P' - 11);
2171 else
2172 p += sprintf((char *)p, "\x1BO%c", code + 'P' - 11);
2173 return p - output;
2174 }
2175 if (cfg.rxvt_homeend && (code == 1 || code == 4)) {
2176 p += sprintf((char *)p, code == 1 ? "\x1B[H" : "\x1BOw");
2177 return p - output;
2178 }
2179 if (code) {
2180 p += sprintf((char *)p, "\x1B[%d~", code);
2181 return p - output;
2182 }
2183
2184 /*
2185 * Now the remaining keys (arrows and Keypad 5. Keypad 5 for
2186 * some reason seems to send VK_CLEAR to Windows...).
2187 */
2188 {
2189 char xkey = 0;
2190 switch (wParam) {
2191 case VK_UP: xkey = 'A'; break;
2192 case VK_DOWN: xkey = 'B'; break;
2193 case VK_RIGHT: xkey = 'C'; break;
2194 case VK_LEFT: xkey = 'D'; break;
2195 case VK_CLEAR: xkey = 'G'; break;
2196 }
2197 if (xkey)
2198 {
2199 if (vt52_mode)
2200 p += sprintf((char *)p, "\x1B%c", xkey);
2201 else if (app_cursor_keys)
2202 p += sprintf((char *)p, "\x1BO%c", xkey);
2203 else
2204 p += sprintf((char *)p, "\x1B[%c", xkey);
2205 return p - output;
2206 }
2207 }
2208
2209 /*
2210 * Finally, deal with Return ourselves. (Win95 seems to
2211 * foul it up when Alt is pressed, for some reason.)
2212 */
2213 if (wParam == VK_RETURN) /* Return */
2214 {
2215 *p++ = 0x0D;
2216 return p-output;
2217 }
2218 }
2219
2220 /* Okay we've done everything interesting; let windows deal with
2221 * the boring stuff */
2222 {
2223 BOOL capsOn=keystate[VK_CAPITAL] !=0;
2224
2225 /* helg: clear CAPS LOCK state if caps lock switches to cyrillic */
2226 if(cfg.xlat_capslockcyr)
2227 keystate[VK_CAPITAL] = 0;
2228
2229 r = ToAscii (wParam, scan, keystate, keys, 0);
2230 if(r>0)
2231 {
2232 p = output;
2233 for(i=0; i<r; i++)
2234 {
2235 unsigned char ch = (unsigned char)keys[i];
2236
2237 if (compose_state==2 && (ch&0x80) == 0 && ch>' ') {
2238 compose_char = ch;
2239 compose_state ++;
2240 continue;
2241 }
2242 if (compose_state==3 && (ch&0x80) == 0 && ch>' ') {
2243 int nc;
2244 compose_state = 0;
2245
2246 if ((nc=check_compose(compose_char,ch)) == -1)
2247 {
2248 MessageBeep(MB_ICONHAND);
2249 return 0;
2250 }
2251 *p++ = xlat_kbd2tty((unsigned char)nc);
2252 return p-output;
2253 }
2254
2255 compose_state = 0;
2256
2257 if( left_alt && key_down ) *p++ = '\033';
2258 if (!key_down)
2259 *p++ = ch;
2260 else
2261 {
2262 if(capsOn)
2263 ch = xlat_latkbd2win(ch);
2264 *p++ = xlat_kbd2tty(ch);
2265 }
2266 }
2267
2268 /* This is so the ALT-Numpad and dead keys work correctly. */
2269 keys[0] = 0;
2270
2271 return p-output;
2272 }
2273 }
2274
2275 /* This stops ALT press-release doing a 'COMMAND MENU' function */
2276 if (!cfg.alt_only) {
2277 if (message == WM_SYSKEYUP && wParam == VK_MENU)
2278 return 0;
2279 }
2280
2281 return -1;
2282 }
2283
2284 void set_title (char *title) {
2285 sfree (window_name);
2286 window_name = smalloc(1+strlen(title));
2287 strcpy (window_name, title);
2288 if (cfg.win_name_always || !IsIconic(hwnd))
2289 SetWindowText (hwnd, title);
2290 }
2291
2292 void set_icon (char *title) {
2293 sfree (icon_name);
2294 icon_name = smalloc(1+strlen(title));
2295 strcpy (icon_name, title);
2296 if (!cfg.win_name_always && IsIconic(hwnd))
2297 SetWindowText (hwnd, title);
2298 }
2299
2300 void set_sbar (int total, int start, int page) {
2301 SCROLLINFO si;
2302
2303 if (!cfg.scrollbar) return;
2304
2305 si.cbSize = sizeof(si);
2306 si.fMask = SIF_ALL | SIF_DISABLENOSCROLL;
2307 si.nMin = 0;
2308 si.nMax = total - 1;
2309 si.nPage = page;
2310 si.nPos = start;
2311 if (hwnd)
2312 SetScrollInfo (hwnd, SB_VERT, &si, TRUE);
2313 }
2314
2315 Context get_ctx(void) {
2316 HDC hdc;
2317 if (hwnd) {
2318 hdc = GetDC (hwnd);
2319 if (hdc && pal)
2320 SelectPalette (hdc, pal, FALSE);
2321 return hdc;
2322 } else
2323 return NULL;
2324 }
2325
2326 void free_ctx (Context ctx) {
2327 SelectPalette (ctx, GetStockObject (DEFAULT_PALETTE), FALSE);
2328 ReleaseDC (hwnd, ctx);
2329 }
2330
2331 static void real_palette_set (int n, int r, int g, int b) {
2332 if (pal) {
2333 logpal->palPalEntry[n].peRed = r;
2334 logpal->palPalEntry[n].peGreen = g;
2335 logpal->palPalEntry[n].peBlue = b;
2336 logpal->palPalEntry[n].peFlags = PC_NOCOLLAPSE;
2337 colours[n] = PALETTERGB(r, g, b);
2338 SetPaletteEntries (pal, 0, NCOLOURS, logpal->palPalEntry);
2339 } else
2340 colours[n] = RGB(r, g, b);
2341 }
2342
2343 void palette_set (int n, int r, int g, int b) {
2344 static const int first[21] = {
2345 0, 2, 4, 6, 8, 10, 12, 14,
2346 1, 3, 5, 7, 9, 11, 13, 15,
2347 16, 17, 18, 20, 22
2348 };
2349 real_palette_set (first[n], r, g, b);
2350 if (first[n] >= 18)
2351 real_palette_set (first[n]+1, r, g, b);
2352 if (pal) {
2353 HDC hdc = get_ctx();
2354 UnrealizeObject (pal);
2355 RealizePalette (hdc);
2356 free_ctx (hdc);
2357 }
2358 }
2359
2360 void palette_reset (void) {
2361 int i;
2362
2363 for (i = 0; i < NCOLOURS; i++) {
2364 if (pal) {
2365 logpal->palPalEntry[i].peRed = defpal[i].rgbtRed;
2366 logpal->palPalEntry[i].peGreen = defpal[i].rgbtGreen;
2367 logpal->palPalEntry[i].peBlue = defpal[i].rgbtBlue;
2368 logpal->palPalEntry[i].peFlags = 0;
2369 colours[i] = PALETTERGB(defpal[i].rgbtRed,
2370 defpal[i].rgbtGreen,
2371 defpal[i].rgbtBlue);
2372 } else
2373 colours[i] = RGB(defpal[i].rgbtRed,
2374 defpal[i].rgbtGreen,
2375 defpal[i].rgbtBlue);
2376 }
2377
2378 if (pal) {
2379 HDC hdc;
2380 SetPaletteEntries (pal, 0, NCOLOURS, logpal->palPalEntry);
2381 hdc = get_ctx();
2382 RealizePalette (hdc);
2383 free_ctx (hdc);
2384 }
2385 }
2386
2387 void write_clip (void *data, int len, int must_deselect) {
2388 HGLOBAL clipdata;
2389 void *lock;
2390
2391 clipdata = GlobalAlloc (GMEM_DDESHARE | GMEM_MOVEABLE, len + 1);
2392 if (!clipdata)
2393 return;
2394 lock = GlobalLock (clipdata);
2395 if (!lock)
2396 return;
2397 memcpy (lock, data, len);
2398 ((unsigned char *) lock) [len] = 0;
2399 GlobalUnlock (clipdata);
2400
2401 if (!must_deselect)
2402 SendMessage (hwnd, WM_IGNORE_CLIP, TRUE, 0);
2403
2404 if (OpenClipboard (hwnd)) {
2405 EmptyClipboard();
2406 SetClipboardData (CF_TEXT, clipdata);
2407 CloseClipboard();
2408 } else
2409 GlobalFree (clipdata);
2410
2411 if (!must_deselect)
2412 SendMessage (hwnd, WM_IGNORE_CLIP, FALSE, 0);
2413 }
2414
2415 void get_clip (void **p, int *len) {
2416 static HGLOBAL clipdata = NULL;
2417
2418 if (!p) {
2419 if (clipdata)
2420 GlobalUnlock (clipdata);
2421 clipdata = NULL;
2422 return;
2423 } else {
2424 if (OpenClipboard (NULL)) {
2425 clipdata = GetClipboardData (CF_TEXT);
2426 CloseClipboard();
2427 if (clipdata) {
2428 *p = GlobalLock (clipdata);
2429 if (*p) {
2430 *len = strlen(*p);
2431 return;
2432 }
2433 }
2434 }
2435 }
2436
2437 *p = NULL;
2438 *len = 0;
2439 }
2440
2441 /*
2442 * Move `lines' lines from position `from' to position `to' in the
2443 * window.
2444 */
2445 void optimised_move (int to, int from, int lines) {
2446 RECT r;
2447 int min, max;
2448
2449 min = (to < from ? to : from);
2450 max = to + from - min;
2451
2452 r.left = 0; r.right = cols * font_width;
2453 r.top = min * font_height; r.bottom = (max+lines) * font_height;
2454 ScrollWindow (hwnd, 0, (to - from) * font_height, &r, &r);
2455 }
2456
2457 /*
2458 * Print a message box and perform a fatal exit.
2459 */
2460 void fatalbox(char *fmt, ...) {
2461 va_list ap;
2462 char stuff[200];
2463
2464 va_start(ap, fmt);
2465 vsprintf(stuff, fmt, ap);
2466 va_end(ap);
2467 MessageBox(hwnd, stuff, "PuTTY Fatal Error", MB_ICONERROR | MB_OK);
2468 exit(1);
2469 }
2470
2471 /*
2472 * Beep.
2473 */
2474 void beep(int errorbeep) {
2475 static long last_beep = 0;
2476 long now, beep_diff;
2477
2478 now = GetTickCount();
2479 beep_diff = now-last_beep;
2480
2481 /* Make sure we only respond to one beep per packet or so */
2482 if (beep_diff>=0 && beep_diff<50)
2483 return;
2484
2485 if(errorbeep)
2486 MessageBeep(MB_ICONHAND);
2487 else
2488 MessageBeep(MB_OK);
2489
2490 last_beep = GetTickCount();
2491 }