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