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