window.c

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