window.c

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