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 == COE_ALWAYS)
 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 && !session_closed) {
 696         /* Abnormal exits will already have set session_closed and taken
 697          * appropriate action. */
 698         if (cfg.close_on_exit == COE_ALWAYS ||
 699             cfg.close_on_exit == COE_NORMAL)
 700             PostQuitMessage(0);
 701         else {
 702             session_closed = TRUE;
 703             SetWindowText (hwnd, "PuTTY (inactive)");
 704             MessageBox(hwnd, "Connection closed by remote host",
 705                        "PuTTY", MB_OK | MB_ICONINFORMATION);
 706         }
 707     }
 708 }
 709
 710 /*
 711  * Copy the colour palette from the configuration data into defpal.
 712  * This is non-trivial because the colour indices are different.
 713  */
 714 static void cfgtopalette(void) {
 715     int i;
 716     static const int ww[] = {
 717         6, 7, 8, 9, 10, 11, 12, 13,
 718         14, 15, 16, 17, 18, 19, 20, 21,
 719         0, 1, 2, 3, 4, 4, 5, 5
 720     };
 721
 722     for (i=0; i<24; i++) {
 723         int w = ww[i];
 724         defpal[i].rgbtRed = cfg.colours[w][0];
 725         defpal[i].rgbtGreen = cfg.colours[w][1];
 726         defpal[i].rgbtBlue = cfg.colours[w][2];
 727     }
 728 }
 729
 730 /*
 731  * Set up the colour palette.
 732  */
 733 static void init_palette(void) {
 734     int i;
 735     HDC hdc = GetDC (hwnd);
 736     if (hdc) {
 737         if (cfg.try_palette &&
 738             GetDeviceCaps (hdc, RASTERCAPS) & RC_PALETTE) {
 739             logpal = smalloc(sizeof(*logpal)
 740                              - sizeof(logpal->palPalEntry)
 741                              + NCOLOURS * sizeof(PALETTEENTRY));
 742             logpal->palVersion = 0x300;
 743             logpal->palNumEntries = NCOLOURS;
 744             for (i = 0; i < NCOLOURS; i++) {
 745                 logpal->palPalEntry[i].peRed = defpal[i].rgbtRed;
 746                 logpal->palPalEntry[i].peGreen = defpal[i].rgbtGreen;
 747                 logpal->palPalEntry[i].peBlue = defpal[i].rgbtBlue;
 748                 logpal->palPalEntry[i].peFlags = PC_NOCOLLAPSE;
 749             }
 750             pal = CreatePalette (logpal);
 751             if (pal) {
 752                 SelectPalette (hdc, pal, FALSE);
 753                 RealizePalette (hdc);
 754                 SelectPalette (hdc, GetStockObject (DEFAULT_PALETTE),
 755                                FALSE);
 756             }
 757         }
 758         ReleaseDC (hwnd, hdc);
 759     }
 760     if (pal)
 761         for (i=0; i<NCOLOURS; i++)
 762             colours[i] = PALETTERGB(defpal[i].rgbtRed,
 763                                     defpal[i].rgbtGreen,
 764                                     defpal[i].rgbtBlue);
 765     else
 766         for(i=0; i<NCOLOURS; i++)
 767             colours[i] = RGB(defpal[i].rgbtRed,
 768                              defpal[i].rgbtGreen,
 769                              defpal[i].rgbtBlue);
 770 }
 771
 772 /*
 773  * Initialise all the fonts we will need. There may be as many as
 774  * eight or as few as one. We also:
 775  *
 776  * - check the font width and height, correcting our guesses if
 777  *   necessary.
 778  *
 779  * - verify that the bold font is the same width as the ordinary
 780  *   one, and engage shadow bolding if not.
 781  *
 782  * - verify that the underlined font is the same width as the
 783  *   ordinary one (manual underlining by means of line drawing can
 784  *   be done in a pinch).
 785  */
 786 static void init_fonts(int pick_width) {
 787     TEXTMETRIC tm;
 788     int i;
 789     int fsize[8];
 790     HDC hdc;
 791     int fw_dontcare, fw_bold;
 792     int firstchar = ' ';
 793
 794 #ifdef CHECKOEMFONT
 795 font_messup:
 796 #endif
 797     for (i=0; i<8; i++)
 798         fonts[i] = NULL;
 799
 800     if (cfg.fontisbold) {
 801         fw_dontcare = FW_BOLD;
 802         fw_bold = FW_HEAVY;
 803    } else {
 804         fw_dontcare = FW_DONTCARE;
 805         fw_bold = FW_BOLD;
 806     }
 807
 808     hdc = GetDC(hwnd);
 809
 810     font_height = cfg.fontheight;
 811     font_width = pick_width;
 812
 813 #define f(i,c,w,u) \
 814     fonts[i] = CreateFont (font_height, font_width, 0, 0, w, FALSE, u, FALSE, \
 815                            c, OUT_DEFAULT_PRECIS, \
 816                            CLIP_DEFAULT_PRECIS, DEFAULT_QUALITY, \
 817                            FIXED_PITCH | FF_DONTCARE, cfg.font)
 818
 819     if (cfg.vtmode != VT_OEMONLY) {
 820         f(FONT_NORMAL, cfg.fontcharset, fw_dontcare, FALSE);
 821
 822         SelectObject (hdc, fonts[FONT_NORMAL]);
 823         GetTextMetrics(hdc, &tm);
 824         font_height = tm.tmHeight;
 825         font_width = tm.tmAveCharWidth;
 826
 827         f(FONT_UNDERLINE, cfg.fontcharset, fw_dontcare, TRUE);
 828
 829         /*
 830          * Some fonts, e.g. 9-pt Courier, draw their underlines
 831          * outside their character cell. We successfully prevent
 832          * screen corruption by clipping the text output, but then
 833          * we lose the underline completely. Here we try to work
 834          * out whether this is such a font, and if it is, we set a
 835          * flag that causes underlines to be drawn by hand.
 836          *
 837          * Having tried other more sophisticated approaches (such
 838          * as examining the TEXTMETRIC structure or requesting the
 839          * height of a string), I think we'll do this the brute
 840          * force way: we create a small bitmap, draw an underlined
 841          * space on it, and test to see whether any pixels are
 842          * foreground-coloured. (Since we expect the underline to
 843          * go all the way across the character cell, we only search
 844          * down a single column of the bitmap, half way across.)
 845          */
 846         {
 847             HDC und_dc;
 848             HBITMAP und_bm, und_oldbm;
 849             int i, gotit;
 850             COLORREF c;
 851
 852             und_dc = CreateCompatibleDC(hdc);
 853             und_bm = CreateCompatibleBitmap(hdc, font_width, font_height);
 854             und_oldbm = SelectObject(und_dc, und_bm);
 855             SelectObject(und_dc, fonts[FONT_UNDERLINE]);
 856             SetTextAlign(und_dc, TA_TOP | TA_LEFT | TA_NOUPDATECP);
 857             SetTextColor (und_dc, RGB(255,255,255));
 858             SetBkColor (und_dc, RGB(0,0,0));
 859             SetBkMode (und_dc, OPAQUE);
 860             ExtTextOut (und_dc, 0, 0, ETO_OPAQUE, NULL, " ", 1, NULL);
 861             gotit = FALSE;
 862             for (i = 0; i < font_height; i++) {
 863                 c = GetPixel(und_dc, font_width/2, i);
 864                 if (c != RGB(0,0,0))
 865                     gotit = TRUE;
 866             }
 867             SelectObject(und_dc, und_oldbm);
 868             DeleteObject(und_bm);
 869             DeleteDC(und_dc);
 870             font_needs_hand_underlining = !gotit;
 871         }
 872
 873         if (bold_mode == BOLD_FONT) {
 874             f(FONT_BOLD, cfg.fontcharset, fw_bold, FALSE);
 875             f(FONT_BOLDUND, cfg.fontcharset, fw_bold, TRUE);
 876         }
 877
 878         if (cfg.vtmode == VT_OEMANSI) {
 879             f(FONT_OEM, OEM_CHARSET, fw_dontcare, FALSE);
 880             f(FONT_OEMUND, OEM_CHARSET, fw_dontcare, TRUE);
 881
 882             if (bold_mode == BOLD_FONT) {
 883                 f(FONT_OEMBOLD, OEM_CHARSET, fw_bold, FALSE);
 884                 f(FONT_OEMBOLDUND, OEM_CHARSET, fw_bold, TRUE);
 885             }
 886         }
 887     }
 888     else
 889     {
 890         f(FONT_OEM, cfg.fontcharset, fw_dontcare, FALSE);
 891
 892         SelectObject (hdc, fonts[FONT_OEM]);
 893         GetTextMetrics(hdc, &tm);
 894         font_height = tm.tmHeight;
 895         font_width = tm.tmAveCharWidth;
 896
 897         f(FONT_OEMUND, cfg.fontcharset, fw_dontcare, TRUE);
 898
 899         if (bold_mode == BOLD_FONT) {
 900             f(FONT_BOLD, cfg.fontcharset, fw_bold, FALSE);
 901             f(FONT_BOLDUND, cfg.fontcharset, fw_bold, TRUE);
 902         }
 903     }
 904 #undef f
 905
 906     descent = tm.tmAscent + 1;
 907     if (descent >= font_height)
 908         descent = font_height - 1;
 909     firstchar = tm.tmFirstChar;
 910
 911     for (i=0; i<8; i++) {
 912         if (fonts[i]) {
 913             if (SelectObject (hdc, fonts[i]) &&
 914                 GetTextMetrics(hdc, &tm) )
 915                  fsize[i] = tm.tmAveCharWidth + 256 * tm.tmHeight;
 916             else fsize[i] = -i;
 917         }
 918         else fsize[i] = -i;
 919     }
 920
 921     ReleaseDC (hwnd, hdc);
 922
 923     /* ... This is wrong in OEM only mode */
 924     if (fsize[FONT_UNDERLINE] != fsize[FONT_NORMAL] ||
 925         (bold_mode == BOLD_FONT &&
 926          fsize[FONT_BOLDUND] != fsize[FONT_BOLD])) {
 927         und_mode = UND_LINE;
 928         DeleteObject (fonts[FONT_UNDERLINE]);
 929         if (bold_mode == BOLD_FONT)
 930             DeleteObject (fonts[FONT_BOLDUND]);
 931     }
 932
 933     if (bold_mode == BOLD_FONT &&
 934         fsize[FONT_BOLD] != fsize[FONT_NORMAL]) {
 935         bold_mode = BOLD_SHADOW;
 936         DeleteObject (fonts[FONT_BOLD]);
 937         if (und_mode == UND_FONT)
 938             DeleteObject (fonts[FONT_BOLDUND]);
 939     }
 940
 941 #ifdef CHECKOEMFONT
 942     /* With the fascist font painting it doesn't matter if the linedraw font
 943      * isn't exactly the right size anymore so we don't have to check this.
 944      */
 945     if (cfg.vtmode == VT_OEMANSI && fsize[FONT_OEM] != fsize[FONT_NORMAL] ) {
 946         if( cfg.fontcharset == OEM_CHARSET )
 947         {
 948             MessageBox(NULL, "The OEM and ANSI versions of this font are\n"
 949                    "different sizes. Using OEM-only mode instead",
 950                    "Font Size Mismatch", MB_ICONINFORMATION | MB_OK);
 951             cfg.vtmode = VT_OEMONLY;
 952         }
 953         else if( firstchar < ' ' )
 954         {
 955             MessageBox(NULL, "The OEM and ANSI versions of this font are\n"
 956                    "different sizes. Using XTerm mode instead",
 957                    "Font Size Mismatch", MB_ICONINFORMATION | MB_OK);
 958             cfg.vtmode = VT_XWINDOWS;
 959         }
 960         else
 961         {
 962             MessageBox(NULL, "The OEM and ANSI versions of this font are\n"
 963                    "different sizes. Using ISO8859-1 mode instead",
 964                    "Font Size Mismatch", MB_ICONINFORMATION | MB_OK);
 965             cfg.vtmode = VT_POORMAN;
 966         }
 967
 968         for (i=0; i<8; i++)
 969             if (fonts[i])
 970                 DeleteObject (fonts[i]);
 971         goto font_messup;
 972     }
 973 #endif
 974 }
 975
 976 void request_resize (int w, int h, int refont) {
 977     int width, height;
 978
 979     /* If the window is maximized supress resizing attempts */
 980     if(IsZoomed(hwnd)) return;
 981
 982 #ifdef CHECKOEMFONT
 983     /* Don't do this in OEMANSI, you may get disable messages */
 984     if (refont && w != cols && (cols==80 || cols==132)
 985           && cfg.vtmode != VT_OEMANSI)
 986 #else
 987     if (refont && w != cols && (cols==80 || cols==132))
 988 #endif
 989     {
 990        /* If font width too big for screen should we shrink the font more ? */
 991         if (w==132)
 992             font_width = ((font_width*cols+w/2)/w);
 993         else
 994             font_width = 0;
 995         {
 996             int i;
 997             for (i=0; i<8; i++)
 998                 if (fonts[i])
 999                     DeleteObject(fonts[i]);
1000         }
1001         bold_mode = cfg.bold_colour ? BOLD_COLOURS : BOLD_FONT;
1002         und_mode = UND_FONT;
1003         init_fonts(font_width);
1004     }
1005     else
1006     {
1007        static int first_time = 1;
1008        static RECT ss;
1009
1010        switch(first_time)
1011        {
1012        case 1:
1013              /* Get the size of the screen */
1014              if (GetClientRect(GetDesktopWindow(),&ss))
1015                 /* first_time = 0 */;
1016              else { first_time = 2; break; }
1017        case 0:
1018              /* Make sure the values are sane */
1019              width  = (ss.right-ss.left-extra_width  ) / font_width;
1020              height = (ss.bottom-ss.top-extra_height ) / font_height;
1021
1022              if (w>width)  w=width;
1023              if (h>height) h=height;
1024              if (w<15) w = 15;
1025              if (h<1) w = 1;
1026        }
1027     }
1028
1029     width = extra_width + font_width * w;
1030     height = extra_height + font_height * h;
1031
1032     SetWindowPos (hwnd, NULL, 0, 0, width, height,
1033                   SWP_NOACTIVATE | SWP_NOCOPYBITS |
1034                   SWP_NOMOVE | SWP_NOZORDER);
1035 }
1036
1037 static void click (Mouse_Button b, int x, int y) {
1038     int thistime = GetMessageTime();
1039
1040     if (lastbtn == b && thistime - lasttime < dbltime) {
1041         lastact = (lastact == MA_CLICK ? MA_2CLK :
1042                    lastact == MA_2CLK ? MA_3CLK :
1043                    lastact == MA_3CLK ? MA_CLICK : MA_NOTHING);
1044     } else {
1045         lastbtn = b;
1046         lastact = MA_CLICK;
1047     }
1048     if (lastact != MA_NOTHING)
1049         term_mouse (b, lastact, x, y);
1050     lasttime = thistime;
1051 }
1052
1053 static void show_mouseptr(int show) {
1054     static int cursor_visible = 1;
1055     if (!cfg.hide_mouseptr)            /* override if this feature disabled */
1056         show = 1;
1057     if (cursor_visible && !show)
1058         ShowCursor(FALSE);
1059     else if (!cursor_visible && show)
1060         ShowCursor(TRUE);
1061     cursor_visible = show;
1062 }
1063
1064 static LRESULT CALLBACK WndProc (HWND hwnd, UINT message,
1065                                  WPARAM wParam, LPARAM lParam) {
1066     HDC hdc;
1067     static int ignore_size = FALSE;
1068     static int ignore_clip = FALSE;
1069     static int just_reconfigged = FALSE;
1070     static int resizing = FALSE;
1071     static int need_backend_resize = FALSE;
1072
1073     switch (message) {
1074       case WM_TIMER:
1075         if (pending_netevent)
1076             enact_pending_netevent();
1077         if (inbuf_head)
1078             term_out();
1079         noise_regular();
1080         HideCaret(hwnd);
1081         term_update();
1082         ShowCaret(hwnd);
1083         if (cfg.ping_interval > 0)
1084         {
1085            time_t now;
1086            time(&now);
1087            if (now-last_movement > cfg.ping_interval)
1088            {
1089               back->special(TS_PING);
1090               last_movement = now;
1091            }
1092         }
1093         return 0;
1094       case WM_CREATE:
1095         break;
1096       case WM_CLOSE:
1097         show_mouseptr(1);
1098         if (!cfg.warn_on_close || session_closed ||
1099             MessageBox(hwnd, "Are you sure you want to close this session?",
1100                        "PuTTY Exit Confirmation",
1101                        MB_ICONWARNING | MB_OKCANCEL) == IDOK)
1102             DestroyWindow(hwnd);
1103         return 0;
1104       case WM_DESTROY:
1105         show_mouseptr(1);
1106         PostQuitMessage (0);
1107         return 0;
1108       case WM_SYSCOMMAND:
1109         switch (wParam & ~0xF) {       /* low 4 bits reserved to Windows */
1110           case IDM_SHOWLOG:
1111             showeventlog(hwnd);
1112             break;
1113           case IDM_NEWSESS:
1114           case IDM_DUPSESS:
1115           case IDM_SAVEDSESS:
1116             {
1117                 char b[2048];
1118                 char c[30], *cl;
1119                 int freecl = FALSE;
1120                 STARTUPINFO si;
1121                 PROCESS_INFORMATION pi;
1122                 HANDLE filemap = NULL;
1123
1124                 if (wParam == IDM_DUPSESS) {
1125                     /*
1126                      * Allocate a file-mapping memory chunk for the
1127                      * config structure.
1128                      */
1129                     SECURITY_ATTRIBUTES sa;
1130                     Config *p;
1131
1132                     sa.nLength = sizeof(sa);
1133                     sa.lpSecurityDescriptor = NULL;
1134                     sa.bInheritHandle = TRUE;
1135                     filemap = CreateFileMapping((HANDLE)0xFFFFFFFF,
1136                                                 &sa,
1137                                                 PAGE_READWRITE,
1138                                                 0,
1139                                                 sizeof(Config),
1140                                                 NULL);
1141                     if (filemap) {
1142                         p = (Config *)MapViewOfFile(filemap,
1143                                                     FILE_MAP_WRITE,
1144                                                     0, 0, sizeof(Config));
1145                         if (p) {
1146                             *p = cfg;  /* structure copy */
1147                             UnmapViewOfFile(p);
1148                         }
1149                     }
1150                     sprintf(c, "putty &%p", filemap);
1151                     cl = c;
1152                 } else if (wParam == IDM_SAVEDSESS) {
1153                     char *session = sessions[(lParam - IDM_SAVED_MIN) / 16];
1154                     cl = smalloc(16 + strlen(session)); /* 8, but play safe */
1155                     if (!cl)
1156                         cl = NULL;     /* not a very important failure mode */
1157                     else {
1158                         sprintf(cl, "putty @%s", session);
1159                         freecl = TRUE;
1160                     }
1161                 } else
1162                     cl = NULL;
1163
1164                 GetModuleFileName (NULL, b, sizeof(b)-1);
1165                 si.cb = sizeof(si);
1166                 si.lpReserved = NULL;
1167                 si.lpDesktop = NULL;
1168                 si.lpTitle = NULL;
1169                 si.dwFlags = 0;
1170                 si.cbReserved2 = 0;
1171                 si.lpReserved2 = NULL;
1172                 CreateProcess (b, cl, NULL, NULL, TRUE,
1173                                NORMAL_PRIORITY_CLASS, NULL, NULL, &si, &pi);
1174
1175                 if (filemap)
1176                     CloseHandle(filemap);
1177                 if (freecl)
1178                     sfree(cl);
1179             }
1180             break;
1181           case IDM_RECONF:
1182             {
1183                 int prev_alwaysontop = cfg.alwaysontop;
1184                 char oldlogfile[FILENAME_MAX];
1185                 int oldlogtype;
1186                 int need_setwpos = FALSE;
1187                 int old_fwidth, old_fheight;
1188
1189                 strcpy(oldlogfile, cfg.logfilename);
1190                 oldlogtype = cfg.logtype;
1191                 cfg.width = cols;
1192                 cfg.height = rows;
1193                 old_fwidth = font_width;
1194                 old_fheight = font_height;
1195                 GetWindowText(hwnd, cfg.wintitle, sizeof(cfg.wintitle));
1196
1197                 if (!do_reconfig(hwnd))
1198                     break;
1199
1200                 if (strcmp(oldlogfile, cfg.logfilename) ||
1201                     oldlogtype != cfg.logtype) {
1202                     logfclose();       /* reset logging */
1203                     logfopen();
1204                 }
1205
1206                 just_reconfigged = TRUE;
1207                 {
1208                     int i;
1209                     for (i=0; i<8; i++)
1210                         if (fonts[i])
1211                             DeleteObject(fonts[i]);
1212                 }
1213                 bold_mode = cfg.bold_colour ? BOLD_COLOURS : BOLD_FONT;
1214                 und_mode = UND_FONT;
1215                 init_fonts(0);
1216                 sfree(logpal);
1217                 /*
1218                  * Flush the line discipline's edit buffer in the
1219                  * case where local editing has just been disabled.
1220                  */
1221                 ldisc_send(NULL, 0);
1222                 if (pal)
1223                     DeleteObject(pal);
1224                 logpal = NULL;
1225                 pal = NULL;
1226                 cfgtopalette();
1227                 init_palette();
1228
1229                 /* Enable or disable the scroll bar, etc */
1230                 {
1231                     LONG nflg, flag = GetWindowLong(hwnd, GWL_STYLE);
1232                     LONG nexflag, exflag = GetWindowLong(hwnd, GWL_EXSTYLE);
1233
1234                     nexflag = exflag;
1235                     if (cfg.alwaysontop != prev_alwaysontop) {
1236                         if (cfg.alwaysontop) {
1237                             nexflag = WS_EX_TOPMOST;
1238                             SetWindowPos(hwnd, HWND_TOPMOST, 0, 0, 0, 0,
1239                                          SWP_NOMOVE | SWP_NOSIZE);
1240                         } else {
1241                             nexflag = 0;
1242                             SetWindowPos(hwnd, HWND_NOTOPMOST, 0, 0, 0, 0,
1243                                          SWP_NOMOVE | SWP_NOSIZE);
1244                         }
1245                     }
1246
1247                     nflg = flag;
1248                     if (cfg.scrollbar) nflg |=  WS_VSCROLL;
1249                     else               nflg &= ~WS_VSCROLL;
1250                     if (cfg.locksize)
1251                         nflg &= ~(WS_THICKFRAME|WS_MAXIMIZEBOX);
1252                     else
1253                         nflg |= (WS_THICKFRAME|WS_MAXIMIZEBOX);
1254
1255                     if (nflg != flag || nexflag != exflag)
1256                     {
1257                         RECT cr, wr;
1258
1259                         if (nflg != flag)
1260                             SetWindowLong(hwnd, GWL_STYLE, nflg);
1261                         if (nexflag != exflag)
1262                             SetWindowLong(hwnd, GWL_EXSTYLE, nexflag);
1263
1264                         SendMessage (hwnd, WM_IGNORE_SIZE, 0, 0);
1265
1266                         SetWindowPos(hwnd, NULL, 0,0,0,0,
1267                                      SWP_NOACTIVATE|SWP_NOCOPYBITS|
1268                                      SWP_NOMOVE|SWP_NOSIZE|SWP_NOZORDER|
1269                                      SWP_FRAMECHANGED);
1270
1271                         GetWindowRect (hwnd, &wr);
1272                         GetClientRect (hwnd, &cr);
1273                         extra_width = wr.right - wr.left - cr.right + cr.left;
1274                         extra_height = wr.bottom - wr.top - cr.bottom + cr.top;
1275                     }
1276                 }
1277
1278                 if (cfg.height != rows ||
1279                     cfg.width != cols ||
1280                     old_fwidth != font_width ||
1281                     old_fheight != font_height ||
1282                     cfg.savelines != savelines)
1283                     need_setwpos = TRUE;
1284                 term_size(cfg.height, cfg.width, cfg.savelines);
1285                 InvalidateRect(hwnd, NULL, TRUE);
1286                 if (need_setwpos) {
1287                     force_normal(hwnd);
1288                     SetWindowPos (hwnd, NULL, 0, 0,
1289                                   extra_width + font_width * cfg.width,
1290                                   extra_height + font_height * cfg.height,
1291                                   SWP_NOACTIVATE | SWP_NOCOPYBITS |
1292                                   SWP_NOMOVE | SWP_NOZORDER);
1293                 }
1294                 set_title(cfg.wintitle);
1295                 if (IsIconic(hwnd)) {
1296                     SetWindowText (hwnd,
1297                                    cfg.win_name_always ? window_name : icon_name);
1298                 }
1299             }
1300             break;
1301           case IDM_COPYALL:
1302             term_copyall();
1303             break;
1304           case IDM_CLRSB:
1305             term_clrsb();
1306             break;
1307           case IDM_RESET:
1308             term_pwron();
1309             break;
1310           case IDM_TEL_AYT: back->special (TS_AYT); break;
1311           case IDM_TEL_BRK: back->special (TS_BRK); break;
1312           case IDM_TEL_SYNCH: back->special (TS_SYNCH); break;
1313           case IDM_TEL_EC: back->special (TS_EC); break;
1314           case IDM_TEL_EL: back->special (TS_EL); break;
1315           case IDM_TEL_GA: back->special (TS_GA); break;
1316           case IDM_TEL_NOP: back->special (TS_NOP); break;
1317           case IDM_TEL_ABORT: back->special (TS_ABORT); break;
1318           case IDM_TEL_AO: back->special (TS_AO); break;
1319           case IDM_TEL_IP: back->special (TS_IP); break;
1320           case IDM_TEL_SUSP: back->special (TS_SUSP); break;
1321           case IDM_TEL_EOR: back->special (TS_EOR); break;
1322           case IDM_TEL_EOF: back->special (TS_EOF); break;
1323           case IDM_ABOUT:
1324             showabout (hwnd);
1325             break;
1326         default:
1327           if (wParam >= IDM_SAVED_MIN && wParam <= IDM_SAVED_MAX) {
1328             SendMessage(hwnd, WM_SYSCOMMAND, IDM_SAVEDSESS, wParam);
1329           }
1330         }
1331         break;
1332
1333 #define X_POS(l) ((int)(short)LOWORD(l))
1334 #define Y_POS(l) ((int)(short)HIWORD(l))
1335
1336 #define TO_CHR_X(x) (((x)<0 ? (x)-font_width+1 : (x)) / font_width)
1337 #define TO_CHR_Y(y) (((y)<0 ? (y)-font_height+1: (y)) / font_height)
1338
1339       case WM_LBUTTONDOWN:
1340         show_mouseptr(1);
1341         click (MB_SELECT, TO_CHR_X(X_POS(lParam)),
1342                TO_CHR_Y(Y_POS(lParam)));
1343         SetCapture(hwnd);
1344         return 0;
1345       case WM_LBUTTONUP:
1346         show_mouseptr(1);
1347         term_mouse (MB_SELECT, MA_RELEASE, TO_CHR_X(X_POS(lParam)),
1348                     TO_CHR_Y(Y_POS(lParam)));
1349         ReleaseCapture();
1350         return 0;
1351       case WM_MBUTTONDOWN:
1352         show_mouseptr(1);
1353         SetCapture(hwnd);
1354         click (cfg.mouse_is_xterm ? MB_PASTE : MB_EXTEND,
1355                TO_CHR_X(X_POS(lParam)),
1356                TO_CHR_Y(Y_POS(lParam)));
1357         return 0;
1358       case WM_MBUTTONUP:
1359         show_mouseptr(1);
1360         term_mouse (cfg.mouse_is_xterm ? MB_PASTE : MB_EXTEND,
1361                     MA_RELEASE, TO_CHR_X(X_POS(lParam)),
1362                     TO_CHR_Y(Y_POS(lParam)));
1363         ReleaseCapture();
1364         return 0;
1365       case WM_RBUTTONDOWN:
1366         show_mouseptr(1);
1367         SetCapture(hwnd);
1368         click (cfg.mouse_is_xterm ? MB_EXTEND : MB_PASTE,
1369                TO_CHR_X(X_POS(lParam)),
1370                TO_CHR_Y(Y_POS(lParam)));
1371         return 0;
1372       case WM_RBUTTONUP:
1373         show_mouseptr(1);
1374         term_mouse (cfg.mouse_is_xterm ? MB_EXTEND : MB_PASTE,
1375                     MA_RELEASE, TO_CHR_X(X_POS(lParam)),
1376                     TO_CHR_Y(Y_POS(lParam)));
1377         ReleaseCapture();
1378         return 0;
1379       case WM_MOUSEMOVE:
1380         show_mouseptr(1);
1381         /*
1382          * Add the mouse position and message time to the random
1383          * number noise.
1384          */
1385         noise_ultralight(lParam);
1386
1387         if (wParam & (MK_LBUTTON | MK_MBUTTON | MK_RBUTTON)) {
1388             Mouse_Button b;
1389             if (wParam & MK_LBUTTON)
1390                 b = MB_SELECT;
1391             else if (wParam & MK_MBUTTON)
1392                 b = cfg.mouse_is_xterm ? MB_PASTE : MB_EXTEND;
1393             else
1394                 b = cfg.mouse_is_xterm ? MB_EXTEND : MB_PASTE;
1395             term_mouse (b, MA_DRAG, TO_CHR_X(X_POS(lParam)),
1396                         TO_CHR_Y(Y_POS(lParam)));
1397         }
1398         return 0;
1399       case WM_NCMOUSEMOVE:
1400         show_mouseptr(1);
1401         noise_ultralight(lParam);
1402         return 0;
1403       case WM_IGNORE_CLIP:
1404         ignore_clip = wParam;          /* don't panic on DESTROYCLIPBOARD */
1405         break;
1406       case WM_DESTROYCLIPBOARD:
1407         if (!ignore_clip)
1408             term_deselect();
1409         ignore_clip = FALSE;
1410         return 0;
1411       case WM_PAINT:
1412         {
1413             PAINTSTRUCT p;
1414             HideCaret(hwnd);
1415             hdc = BeginPaint (hwnd, &p);
1416             if (pal) {
1417                 SelectPalette (hdc, pal, TRUE);
1418                 RealizePalette (hdc);
1419             }
1420             term_paint (hdc, p.rcPaint.left, p.rcPaint.top,
1421                         p.rcPaint.right, p.rcPaint.bottom);
1422             SelectObject (hdc, GetStockObject(SYSTEM_FONT));
1423             SelectObject (hdc, GetStockObject(WHITE_PEN));
1424             EndPaint (hwnd, &p);
1425             ShowCaret(hwnd);
1426         }
1427         return 0;
1428       case WM_NETEVENT:
1429         /* Notice we can get multiple netevents, FD_READ, FD_WRITE etc
1430          * but the only one that's likely to try to overload us is FD_READ.
1431          * This means buffering just one is fine.
1432          */
1433         if (pending_netevent)
1434             enact_pending_netevent();
1435
1436         pending_netevent = TRUE;
1437         pend_netevent_wParam=wParam;
1438         pend_netevent_lParam=lParam;
1439         time(&last_movement);
1440         return 0;
1441       case WM_SETFOCUS:
1442         has_focus = TRUE;
1443         CreateCaret(hwnd, caretbm, font_width, font_height);
1444         ShowCaret(hwnd);
1445         compose_state = 0;
1446         term_out();
1447         term_update();
1448         break;
1449       case WM_KILLFOCUS:
1450         show_mouseptr(1);
1451         has_focus = FALSE;
1452         DestroyCaret();
1453         term_out();
1454         term_update();
1455         break;
1456       case WM_IGNORE_SIZE:
1457         ignore_size = TRUE;            /* don't panic on next WM_SIZE msg */
1458         break;
1459       case WM_ENTERSIZEMOVE:
1460         EnableSizeTip(1);
1461         resizing = TRUE;
1462         need_backend_resize = FALSE;
1463         break;
1464       case WM_EXITSIZEMOVE:
1465         EnableSizeTip(0);
1466         resizing = FALSE;
1467         if (need_backend_resize)
1468             back->size();
1469         break;
1470       case WM_SIZING:
1471         {
1472             int width, height, w, h, ew, eh;
1473             LPRECT r = (LPRECT)lParam;
1474
1475             width = r->right - r->left - extra_width;
1476             height = r->bottom - r->top - extra_height;
1477             w = (width + font_width/2) / font_width; if (w < 1) w = 1;
1478             h = (height + font_height/2) / font_height; if (h < 1) h = 1;
1479             UpdateSizeTip(hwnd, w, h);
1480             ew = width - w * font_width;
1481             eh = height - h * font_height;
1482             if (ew != 0) {
1483                 if (wParam == WMSZ_LEFT ||
1484                     wParam == WMSZ_BOTTOMLEFT ||
1485                     wParam == WMSZ_TOPLEFT)
1486                     r->left += ew;
1487                 else
1488                     r->right -= ew;
1489             }
1490             if (eh != 0) {
1491                 if (wParam == WMSZ_TOP ||
1492                     wParam == WMSZ_TOPRIGHT ||
1493                     wParam == WMSZ_TOPLEFT)
1494                     r->top += eh;
1495                 else
1496                     r->bottom -= eh;
1497             }
1498             if (ew || eh)
1499                 return 1;
1500             else
1501                 return 0;
1502         }
1503         /* break;  (never reached) */
1504       case WM_SIZE:
1505         if (wParam == SIZE_MINIMIZED) {
1506             SetWindowText (hwnd,
1507                            cfg.win_name_always ? window_name : icon_name);
1508             break;
1509         }
1510         if (wParam == SIZE_RESTORED || wParam == SIZE_MAXIMIZED)
1511             SetWindowText (hwnd, window_name);
1512         if (!ignore_size) {
1513             int width, height, w, h;
1514 #if 0 /* we have fixed this using WM_SIZING now */
1515             int ew, eh;
1516 #endif
1517
1518             width = LOWORD(lParam);
1519             height = HIWORD(lParam);
1520             w = width / font_width; if (w < 1) w = 1;
1521             h = height / font_height; if (h < 1) h = 1;
1522 #if 0 /* we have fixed this using WM_SIZING now */
1523             ew = width - w * font_width;
1524             eh = height - h * font_height;
1525             if (ew != 0 || eh != 0) {
1526                 RECT r;
1527                 GetWindowRect (hwnd, &r);
1528                 SendMessage (hwnd, WM_IGNORE_SIZE, 0, 0);
1529                 SetWindowPos (hwnd, NULL, 0, 0,
1530                               r.right - r.left - ew, r.bottom - r.top - eh,
1531                               SWP_NOACTIVATE | SWP_NOMOVE | SWP_NOZORDER);
1532             }
1533 #endif
1534             if (w != cols || h != rows || just_reconfigged) {
1535                 term_invalidate();
1536                 term_size (h, w, cfg.savelines);
1537                 /*
1538                  * Don't call back->size in mid-resize. (To prevent
1539                  * massive numbers of resize events getting sent
1540                  * down the connection during an NT opaque drag.)
1541                  */
1542                 if (!resizing)
1543                     back->size();
1544                 else
1545                     need_backend_resize = TRUE;
1546                 just_reconfigged = FALSE;
1547             }
1548         }
1549         ignore_size = FALSE;
1550         return 0;
1551       case WM_VSCROLL:
1552         switch (LOWORD(wParam)) {
1553           case SB_BOTTOM: term_scroll(-1, 0); break;
1554           case SB_TOP: term_scroll(+1, 0); break;
1555           case SB_LINEDOWN: term_scroll (0, +1); break;
1556           case SB_LINEUP: term_scroll (0, -1); break;
1557           case SB_PAGEDOWN: term_scroll (0, +rows/2); break;
1558           case SB_PAGEUP: term_scroll (0, -rows/2); break;
1559           case SB_THUMBPOSITION: case SB_THUMBTRACK:
1560             term_scroll (1, HIWORD(wParam)); break;
1561         }
1562         break;
1563      case WM_PALETTECHANGED:
1564         if ((HWND) wParam != hwnd && pal != NULL) {
1565             HDC hdc = get_ctx();
1566             if (hdc) {
1567                 if (RealizePalette (hdc) > 0)
1568                     UpdateColors (hdc);
1569                 free_ctx (hdc);
1570             }
1571         }
1572         break;
1573       case WM_QUERYNEWPALETTE:
1574         if (pal != NULL) {
1575             HDC hdc = get_ctx();
1576             if (hdc) {
1577                 if (RealizePalette (hdc) > 0)
1578                     UpdateColors (hdc);
1579                 free_ctx (hdc);
1580                 return TRUE;
1581             }
1582         }
1583         return FALSE;
1584       case WM_KEYDOWN:
1585       case WM_SYSKEYDOWN:
1586       case WM_KEYUP:
1587       case WM_SYSKEYUP:
1588         /*
1589          * Add the scan code and keypress timing to the random
1590          * number noise.
1591          */
1592         noise_ultralight(lParam);
1593
1594         /*
1595          * We don't do TranslateMessage since it disassociates the
1596          * resulting CHAR message from the KEYDOWN that sparked it,
1597          * which we occasionally don't want. Instead, we process
1598          * KEYDOWN, and call the Win32 translator functions so that
1599          * we get the translations under _our_ control.
1600          */
1601         {
1602             unsigned char buf[20];
1603             int len;
1604
1605             if (wParam==VK_PROCESSKEY) {
1606                 MSG m;
1607                 m.hwnd = hwnd;
1608                 m.message = WM_KEYDOWN;
1609                 m.wParam = wParam;
1610                 m.lParam = lParam & 0xdfff;
1611                 TranslateMessage(&m);
1612             } else {
1613                 len = TranslateKey (message, wParam, lParam, buf);
1614                 if (len == -1)
1615                     return DefWindowProc (hwnd, message, wParam, lParam);
1616                 ldisc_send (buf, len);
1617
1618                 if (len > 0)
1619                     show_mouseptr(0);
1620             }
1621         }
1622         return 0;
1623       case WM_IME_CHAR:
1624         {
1625             unsigned char buf[2];
1626
1627             buf[1] = wParam;
1628             buf[0] = wParam >> 8;
1629             ldisc_send (buf, 2);
1630         }
1631       case WM_CHAR:
1632       case WM_SYSCHAR:
1633         /*
1634          * Nevertheless, we are prepared to deal with WM_CHAR
1635          * messages, should they crop up. So if someone wants to
1636          * post the things to us as part of a macro manoeuvre,
1637          * we're ready to cope.
1638          */
1639         {
1640             char c = xlat_kbd2tty((unsigned char)wParam);
1641             ldisc_send (&c, 1);
1642         }
1643         return 0;
1644     }
1645
1646     return DefWindowProc (hwnd, message, wParam, lParam);
1647 }
1648
1649 /*
1650  * Move the system caret. (We maintain one, even though it's
1651  * invisible, for the benefit of blind people: apparently some
1652  * helper software tracks the system caret, so we should arrange to
1653  * have one.)
1654  */
1655 void sys_cursor(int x, int y) {
1656     SetCaretPos(x * font_width, y * font_height);
1657 }
1658
1659 /*
1660  * Draw a line of text in the window, at given character
1661  * coordinates, in given attributes.
1662  *
1663  * We are allowed to fiddle with the contents of `text'.
1664  */
1665 void do_text (Context ctx, int x, int y, char *text, int len,
1666               unsigned long attr, int lattr) {
1667     COLORREF fg, bg, t;
1668     int nfg, nbg, nfont;
1669     HDC hdc = ctx;
1670     RECT line_box;
1671     int force_manual_underline = 0;
1672     int fnt_width = font_width*(1+(lattr!=LATTR_NORM));
1673     static int *IpDx = 0, IpDxLEN = 0;;
1674
1675     if (len>IpDxLEN || IpDx[0] != fnt_width) {
1676         int i;
1677         if (len>IpDxLEN) {
1678             sfree(IpDx);
1679             IpDx = smalloc((len+16)*sizeof(int));
1680             IpDxLEN = (len+16);
1681         }
1682         for(i=0; i<IpDxLEN; i++)
1683             IpDx[i] = fnt_width;
1684     }
1685
1686     x *= fnt_width;
1687     y *= font_height;
1688
1689     if ((attr & ATTR_ACTCURS) && cfg.cursor_type == 0) {
1690         attr &= (bold_mode == BOLD_COLOURS ? 0x300200 : 0x300300);
1691         attr ^= ATTR_CUR_XOR;
1692     }
1693
1694     nfont = 0;
1695     if (cfg.vtmode == VT_OEMONLY)
1696         nfont |= FONT_OEM;
1697
1698     /*
1699      * Map high-half characters in order to approximate ISO using
1700      * OEM character set. No characters are missing if the OEM codepage
1701      * is CP850.
1702      */
1703     if (nfont & FONT_OEM) {
1704         int i;
1705         for (i=0; i<len; i++)
1706             if (text[i] >= '\xA0' && text[i] <= '\xFF') {
1707 #if 0
1708                 /* This is CP850 ... perfect translation */
1709                 static const char oemhighhalf[] =
1710                     "\x20\xAD\xBD\x9C\xCF\xBE\xDD\xF5" /* A0-A7 */
1711                     "\xF9\xB8\xA6\xAE\xAA\xF0\xA9\xEE" /* A8-AF */
1712                     "\xF8\xF1\xFD\xFC\xEF\xE6\xF4\xFA" /* B0-B7 */
1713                     "\xF7\xFB\xA7\xAF\xAC\xAB\xF3\xA8" /* B8-BF */
1714                     "\xB7\xB5\xB6\xC7\x8E\x8F\x92\x80" /* C0-C7 */
1715                     "\xD4\x90\xD2\xD3\xDE\xD6\xD7\xD8" /* C8-CF */
1716                     "\xD1\xA5\xE3\xE0\xE2\xE5\x99\x9E" /* D0-D7 */
1717                     "\x9D\xEB\xE9\xEA\x9A\xED\xE8\xE1" /* D8-DF */
1718                     "\x85\xA0\x83\xC6\x84\x86\x91\x87" /* E0-E7 */
1719                     "\x8A\x82\x88\x89\x8D\xA1\x8C\x8B" /* E8-EF */
1720                     "\xD0\xA4\x95\xA2\x93\xE4\x94\xF6" /* F0-F7 */
1721                     "\x9B\x97\xA3\x96\x81\xEC\xE7\x98" /* F8-FF */
1722                     ;
1723 #endif
1724                 /* This is CP437 ... junk translation */
1725                 static const unsigned char oemhighhalf[] = {
1726                     0xff, 0xad, 0x9b, 0x9c, 0x6f, 0x9d, 0x7c, 0x15,
1727                     0x22, 0x43, 0xa6, 0xae, 0xaa, 0x2d, 0x52, 0xc4,
1728                     0xf8, 0xf1, 0xfd, 0x33, 0x27, 0xe6, 0x14, 0xfa,
1729                     0x2c, 0x31, 0xa7, 0xaf, 0xac, 0xab, 0x2f, 0xa8,
1730                     0x41, 0x41, 0x41, 0x41, 0x8e, 0x8f, 0x92, 0x80,
1731                     0x45, 0x90, 0x45, 0x45, 0x49, 0x49, 0x49, 0x49,
1732                     0x44, 0xa5, 0x4f, 0x4f, 0x4f, 0x4f, 0x99, 0x78,
1733                     0xed, 0x55, 0x55, 0x55, 0x9a, 0x59, 0x50, 0xe1,
1734                     0x85, 0xa0, 0x83, 0x61, 0x84, 0x86, 0x91, 0x87,
1735                     0x8a, 0x82, 0x88, 0x89, 0x8d, 0xa1, 0x8c, 0x8b,
1736                     0x0b, 0xa4, 0x95, 0xa2, 0x93, 0x6f, 0x94, 0xf6,
1737                     0xed, 0x97, 0xa3, 0x96, 0x81, 0x79, 0x70, 0x98
1738                 };
1739
1740                 text[i] = oemhighhalf[(unsigned char)text[i] - 0xA0];
1741             }
1742     }
1743
1744     if (attr & ATTR_LINEDRW) {
1745         int i;
1746         /* ISO 8859-1 */
1747         static const char poorman[] =
1748             "*#****\xB0\xB1**+++++-----++++|****\xA3\xB7";
1749
1750         /* CP437 */
1751         static const char oemmap_437[] =
1752             "\x04\xB1****\xF8\xF1**\xD9\xBF\xDA\xC0\xC5"
1753             "\xC4\xC4\xC4\xC4\xC4\xC3\xB4\xC1\xC2\xB3\xF3\xF2\xE3*\x9C\xFA";
1754
1755         /* CP850 */
1756         static const char oemmap_850[] =
1757             "\x04\xB1****\xF8\xF1**\xD9\xBF\xDA\xC0\xC5"
1758             "\xC4\xC4\xC4\xC4\xC4\xC3\xB4\xC1\xC2\xB3****\x9C\xFA";
1759
1760         /* Poor windows font ... eg: windows courier */
1761         static const char oemmap[] =
1762             "*\xB1****\xF8\xF1**\xD9\xBF\xDA\xC0\xC5"
1763             "\xC4\xC4\xC4\xC4\xC4\xC3\xB4\xC1\xC2\xB3****\x9C\xFA";
1764
1765         /*
1766          * Line drawing mapping: map ` thru ~ (0x60 thru 0x7E) to
1767          * VT100 line drawing chars; everything else stays normal.
1768          *
1769          * Actually '_' maps to space too, but that's done before.
1770          */
1771         switch (cfg.vtmode) {
1772           case VT_XWINDOWS:
1773             for (i=0; i<len; i++)
1774                 if (text[i] >= '\x60' && text[i] <= '\x7E')
1775                     text[i] += '\x01' - '\x60';
1776             break;
1777           case VT_OEMANSI:
1778             /* Make sure we actually have an OEM font */
1779             if (fonts[nfont|FONT_OEM]) {
1780           case VT_OEMONLY:
1781                 nfont |= FONT_OEM;
1782                 for (i=0; i<len; i++)
1783                     if (text[i] >= '\x60' && text[i] <= '\x7E')
1784                         text[i] = oemmap[(unsigned char)text[i] - 0x60];
1785                 break;
1786             }
1787           case VT_POORMAN:
1788             for (i=0; i<len; i++)
1789                 if (text[i] >= '\x60' && text[i] <= '\x7E')
1790                     text[i] = poorman[(unsigned char)text[i] - 0x60];
1791             break;
1792         }
1793     }
1794
1795     nfg = 2 * ((attr & ATTR_FGMASK) >> ATTR_FGSHIFT);
1796     nbg = 2 * ((attr & ATTR_BGMASK) >> ATTR_BGSHIFT);
1797     if (bold_mode == BOLD_FONT && (attr & ATTR_BOLD))
1798         nfont |= FONT_BOLD;
1799     if (und_mode == UND_FONT && (attr & ATTR_UNDER))
1800         nfont |= FONT_UNDERLINE;
1801     if (!fonts[nfont])
1802     {
1803         if (nfont&FONT_UNDERLINE)
1804             force_manual_underline = 1;
1805         /* Don't do the same for manual bold, it could be bad news. */
1806
1807         nfont &= ~(FONT_BOLD|FONT_UNDERLINE);
1808     }
1809     if (font_needs_hand_underlining && (attr & ATTR_UNDER))
1810         force_manual_underline = 1;
1811     if (attr & ATTR_REVERSE) {
1812         t = nfg; nfg = nbg; nbg = t;
1813     }
1814     if (bold_mode == BOLD_COLOURS && (attr & ATTR_BOLD))
1815         nfg++;
1816     if (bold_mode == BOLD_COLOURS && (attr & ATTR_BLINK))
1817         nbg++;
1818     fg = colours[nfg];
1819     bg = colours[nbg];
1820     SelectObject (hdc, fonts[nfont]);
1821     SetTextColor (hdc, fg);
1822     SetBkColor (hdc, bg);
1823     SetBkMode (hdc, OPAQUE);
1824     line_box.left   = x;
1825     line_box.top    = y;
1826     line_box.right  = x+fnt_width*len;
1827     line_box.bottom = y+font_height;
1828     ExtTextOut (hdc, x, y, ETO_CLIPPED|ETO_OPAQUE, &line_box, text, len, IpDx);
1829     if (bold_mode == BOLD_SHADOW && (attr & ATTR_BOLD)) {
1830         SetBkMode (hdc, TRANSPARENT);
1831
1832        /* GRR: This draws the character outside it's box and can leave
1833         * 'droppings' even with the clip box! I suppose I could loop it
1834         * one character at a time ... yuk.
1835         *
1836         * Or ... I could do a test print with "W", and use +1 or -1 for this
1837         * shift depending on if the leftmost column is blank...
1838         */
1839         ExtTextOut (hdc, x-1, y, ETO_CLIPPED, &line_box, text, len, IpDx);
1840     }
1841     if (force_manual_underline ||
1842             (und_mode == UND_LINE && (attr & ATTR_UNDER))) {
1843         HPEN oldpen;
1844         oldpen = SelectObject (hdc, CreatePen(PS_SOLID, 0, fg));
1845         MoveToEx (hdc, x, y+descent, NULL);
1846         LineTo (hdc, x+len*fnt_width, y+descent);
1847         oldpen = SelectObject (hdc, oldpen);
1848         DeleteObject (oldpen);
1849     }
1850     if ((attr & ATTR_PASCURS) && cfg.cursor_type == 0) {
1851         POINT pts[5];
1852         HPEN oldpen;
1853         pts[0].x = pts[1].x = pts[4].x = x;
1854         pts[2].x = pts[3].x = x+fnt_width-1;
1855         pts[0].y = pts[3].y = pts[4].y = y;
1856         pts[1].y = pts[2].y = y+font_height-1;
1857         oldpen = SelectObject (hdc, CreatePen(PS_SOLID, 0, colours[23]));
1858         Polyline (hdc, pts, 5);
1859         oldpen = SelectObject (hdc, oldpen);
1860         DeleteObject (oldpen);
1861     }
1862     if ((attr & (ATTR_ACTCURS | ATTR_PASCURS)) && cfg.cursor_type != 0) {
1863         int startx, starty, dx, dy, length, i;
1864         if (cfg.cursor_type == 1) {
1865             startx = x; starty = y+descent;
1866             dx = 1; dy = 0; length = fnt_width;
1867         } else {
1868             int xadjust = 0;
1869             if (attr & ATTR_RIGHTCURS)
1870                 xadjust = fnt_width-1;
1871             startx = x+xadjust; starty = y;
1872             dx = 0; dy = 1; length = font_height;
1873         }
1874         if (attr & ATTR_ACTCURS) {
1875             HPEN oldpen;
1876             oldpen = SelectObject (hdc, CreatePen(PS_SOLID, 0, colours[23]));
1877             MoveToEx (hdc, startx, starty, NULL);
1878             LineTo (hdc, startx+dx*length, starty+dy*length);
1879             oldpen = SelectObject (hdc, oldpen);
1880             DeleteObject (oldpen);
1881         } else {
1882             for (i = 0; i < length; i++) {
1883                 if (i % 2 == 0) {
1884                     SetPixel(hdc, startx, starty, colours[23]);
1885                 }
1886                 startx += dx; starty += dy;
1887             }
1888         }
1889     }
1890 }
1891
1892 static int check_compose(int first, int second) {
1893
1894     static char * composetbl[] = {
1895        "++#", "AA@", "(([", "//\\", "))]", "(-{", "-)}", "/^|", "!!¡", "C/¢",
1896        "C|¢", "L-£", "L=£", "XO¤", "X0¤", "Y-¥", "Y=¥", "||¦", "SO§", "S!§",
1897        "S0§", "\"\"¨", "CO©", "C0©", "A_ª", "<<«", ",-¬", "--", "RO®",
1898        "-^¯", "0^°", "+-±", "2^²", "3^³", "''´", "/Uµ", "P!¶", ".^·", ",,¸",
1899        "1^¹", "O_º", ">>»", "14¼", "12½", "34¾", "??¿", "`AÀ", "'AÁ", "^AÂ",
1900        "~AÃ", "\"AÄ", "*AÅ", "AEÆ", ",CÇ", "`EÈ", "'EÉ", "^EÊ", "\"EË",
1901        "`IÌ", "'IÍ", "^IÎ", "\"IÏ", "-DÐ", "~NÑ", "`OÒ", "'OÓ", "^OÔ",
1902        "~OÕ", "\"OÖ", "XX×", "/OØ", "`UÙ", "'UÚ", "^UÛ", "\"UÜ", "'YÝ",
1903        "HTÞ", "ssß", "`aà", "'aá", "^aâ", "~aã", "\"aä", "*aå", "aeæ", ",cç",
1904        "`eè", "'eé", "^eê", "\"eë", "`iì", "'ií", "^iî", "\"iï", "-dð", "~nñ",
1905        "`oò", "'oó", "^oô", "~oõ", "\"oö", ":-÷", "o/ø", "`uù", "'uú", "^uû",
1906        "\"uü", "'yý", "htþ", "\"yÿ",
1907     0};
1908
1909     char ** c;
1910     static int recurse = 0;
1911     int nc = -1;
1912
1913     for(c=composetbl; *c; c++) {
1914         if( (*c)[0] == first && (*c)[1] == second)
1915         {
1916             return (*c)[2] & 0xFF;
1917         }
1918     }
1919
1920     if(recurse==0)
1921     {
1922         recurse=1;
1923         nc = check_compose(second, first);
1924         if(nc == -1)
1925             nc = check_compose(toupper(first), toupper(second));
1926         if(nc == -1)
1927             nc = check_compose(toupper(second), toupper(first));
1928         recurse=0;
1929     }
1930     return nc;
1931 }
1932
1933
1934 /*
1935  * Translate a WM_(SYS)?KEY(UP|DOWN) message into a string of ASCII
1936  * codes. Returns number of bytes used or zero to drop the message
1937  * or -1 to forward the message to windows.
1938  */
1939 static int TranslateKey(UINT message, WPARAM wParam, LPARAM lParam,
1940                         unsigned char *output) {
1941     BYTE keystate[256];
1942     int  scan, left_alt = 0, key_down, shift_state;
1943     int  r, i, code;
1944     unsigned char * p = output;
1945     static int alt_state = 0;
1946
1947     HKL kbd_layout = GetKeyboardLayout(0);
1948
1949     static WORD keys[3];
1950     static int compose_char = 0;
1951     static WPARAM compose_key = 0;
1952
1953     r = GetKeyboardState(keystate);
1954     if (!r) memset(keystate, 0, sizeof(keystate));
1955     else
1956     {
1957 #if 0
1958        {  /* Tell us all about key events */
1959           static BYTE oldstate[256];
1960           static int first = 1;
1961           static int scan;
1962           int ch;
1963           if(first) memcpy(oldstate, keystate, sizeof(oldstate));
1964           first=0;
1965
1966           if ((HIWORD(lParam)&(KF_UP|KF_REPEAT))==KF_REPEAT) {
1967              debug(("+"));
1968           } else if ((HIWORD(lParam)&KF_UP) && scan==(HIWORD(lParam) & 0xFF) ) {
1969              debug((". U"));
1970           } else {
1971              debug((".\n"));
1972              if (wParam >= VK_F1 && wParam <= VK_F20 )
1973                 debug(("K_F%d", wParam+1-VK_F1));
1974              else switch(wParam)
1975              {
1976              case VK_SHIFT:   debug(("SHIFT")); break;
1977              case VK_CONTROL: debug(("CTRL")); break;
1978              case VK_MENU:    debug(("ALT")); break;
1979              default:         debug(("VK_%02x", wParam));
1980              }
1981              if(message == WM_SYSKEYDOWN || message == WM_SYSKEYUP)
1982                 debug(("*"));
1983              debug((", S%02x", scan=(HIWORD(lParam) & 0xFF) ));
1984
1985              ch = MapVirtualKeyEx(wParam, 2, kbd_layout);
1986              if (ch>=' ' && ch<='~') debug((", '%c'", ch));
1987              else if (ch)            debug((", $%02x", ch));
1988
1989              if (keys[0]) debug((", KB0=%02x", keys[0]));
1990              if (keys[1]) debug((", KB1=%02x", keys[1]));
1991              if (keys[2]) debug((", KB2=%02x", keys[2]));
1992
1993              if ( (keystate[VK_SHIFT]&0x80)!=0)     debug((", S"));
1994              if ( (keystate[VK_CONTROL]&0x80)!=0)   debug((", C"));
1995              if ( (HIWORD(lParam)&KF_EXTENDED) )    debug((", E"));
1996              if ( (HIWORD(lParam)&KF_UP) )          debug((", U"));
1997           }
1998
1999           if ((HIWORD(lParam)&(KF_UP|KF_REPEAT))==KF_REPEAT)
2000              ;
2001           else if ( (HIWORD(lParam)&KF_UP) )
2002              oldstate[wParam&0xFF] ^= 0x80;
2003           else
2004              oldstate[wParam&0xFF] ^= 0x81;
2005
2006           for(ch=0; ch<256; ch++)
2007              if (oldstate[ch] != keystate[ch])
2008                 debug((", M%02x=%02x", ch, keystate[ch]));
2009
2010           memcpy(oldstate, keystate, sizeof(oldstate));
2011        }
2012 #endif
2013
2014         if (wParam == VK_MENU && (HIWORD(lParam)&KF_EXTENDED)) {
2015             keystate[VK_RMENU] = keystate[VK_MENU];
2016         }
2017
2018         /* Note if AltGr was pressed and if it was used as a compose key */
2019         if (cfg.compose_key) {
2020             if (wParam == VK_MENU && (HIWORD(lParam)&KF_EXTENDED))
2021             {
2022                 if (!compose_state) compose_key = wParam;
2023             }
2024             if (wParam == VK_APPS && !compose_state)
2025                 compose_key = wParam;
2026
2027             if (wParam == compose_key)
2028             {
2029                 if (compose_state == 0 && (HIWORD(lParam)&(KF_UP|KF_REPEAT))==0)
2030                     compose_state = 1;
2031                 else if (compose_state == 1 && (HIWORD(lParam)&KF_UP))
2032                     compose_state = 2;
2033                 else
2034                     compose_state = 0;
2035             }
2036             else if (compose_state==1 && wParam != VK_CONTROL)
2037                 compose_state = 0;
2038         } else {
2039             compose_state = 0;
2040         }
2041
2042         /* Nastyness with NUMLock - Shift-NUMLock is left alone though */
2043         if ( (cfg.funky_type == 3 ||
2044               (cfg.funky_type <= 1 && app_keypad_keys && !cfg.no_applic_k))
2045               && wParam==VK_NUMLOCK && !(keystate[VK_SHIFT]&0x80)) {
2046
2047             wParam = VK_EXECUTE;
2048
2049             /* UnToggle NUMLock */
2050             if ((HIWORD(lParam)&(KF_UP|KF_REPEAT))==0)
2051                 keystate[VK_NUMLOCK] ^= 1;
2052         }
2053
2054         /* And write back the 'adjusted' state */
2055         SetKeyboardState (keystate);
2056     }
2057
2058     /* Disable Auto repeat if required */
2059     if (repeat_off && (HIWORD(lParam)&(KF_UP|KF_REPEAT))==KF_REPEAT)
2060        return 0;
2061
2062     if ((HIWORD(lParam)&KF_ALTDOWN) && (keystate[VK_RMENU]&0x80) == 0)
2063         left_alt = 1;
2064
2065     key_down = ((HIWORD(lParam)&KF_UP)==0);
2066
2067     /* Make sure Ctrl-ALT is not the same as AltGr for ToAscii */
2068     if (left_alt && (keystate[VK_CONTROL]&0x80))
2069         keystate[VK_MENU] = 0;
2070
2071     scan = (HIWORD(lParam) & (KF_UP | KF_EXTENDED | 0xFF));
2072     shift_state = ((keystate[VK_SHIFT]&0x80)!=0)
2073                 + ((keystate[VK_CONTROL]&0x80)!=0)*2;
2074
2075     /*
2076      * Record that we pressed key so the scroll window can be reset, but
2077      * be careful to avoid Shift-UP/Down
2078      */
2079     if( wParam != VK_SHIFT && wParam != VK_PRIOR && wParam != VK_NEXT ) {
2080         seen_key_event = 1;
2081     }
2082
2083     /* Make sure we're not pasting */
2084     if (key_down) term_nopaste();
2085
2086     if (compose_state>1 && left_alt) compose_state = 0;
2087
2088     /* Sanitize the number pad if not using a PC NumPad */
2089     if( left_alt || (app_keypad_keys && !cfg.no_applic_k
2090                      && cfg.funky_type != 2)
2091         || cfg.funky_type == 3 || cfg.nethack_keypad || compose_state )
2092     {
2093         if ((HIWORD(lParam)&KF_EXTENDED) == 0)
2094         {
2095             int nParam = 0;
2096             switch(wParam)
2097             {
2098             case VK_INSERT:     nParam = VK_NUMPAD0; break;
2099             case VK_END:        nParam = VK_NUMPAD1; break;
2100             case VK_DOWN:       nParam = VK_NUMPAD2; break;
2101             case VK_NEXT:       nParam = VK_NUMPAD3; break;
2102             case VK_LEFT:       nParam = VK_NUMPAD4; break;
2103             case VK_CLEAR:      nParam = VK_NUMPAD5; break;
2104             case VK_RIGHT:      nParam = VK_NUMPAD6; break;
2105             case VK_HOME:       nParam = VK_NUMPAD7; break;
2106             case VK_UP:         nParam = VK_NUMPAD8; break;
2107             case VK_PRIOR:      nParam = VK_NUMPAD9; break;
2108             case VK_DELETE:     nParam = VK_DECIMAL; break;
2109             }
2110             if (nParam)
2111             {
2112                 if (keystate[VK_NUMLOCK]&1) shift_state |= 1;
2113                 wParam = nParam;
2114             }
2115         }
2116     }
2117
2118     /* If a key is pressed and AltGr is not active */
2119     if (key_down && (keystate[VK_RMENU]&0x80) == 0 && !compose_state)
2120     {
2121         /* Okay, prepare for most alts then ...*/
2122         if (left_alt) *p++ = '\033';
2123
2124         /* Lets see if it's a pattern we know all about ... */
2125         if (wParam == VK_PRIOR && shift_state == 1) {
2126             SendMessage (hwnd, WM_VSCROLL, SB_PAGEUP, 0);
2127             return 0;
2128         }
2129         if (wParam == VK_NEXT && shift_state == 1) {
2130             SendMessage (hwnd, WM_VSCROLL, SB_PAGEDOWN, 0);
2131             return 0;
2132         }
2133         if (wParam == VK_INSERT && shift_state == 1) {
2134             term_mouse (MB_PASTE, MA_CLICK, 0, 0);
2135             term_mouse (MB_PASTE, MA_RELEASE, 0, 0);
2136             return 0;
2137         }
2138         if (left_alt && wParam == VK_F4 && cfg.alt_f4) {
2139             return -1;
2140         }
2141         if (left_alt && wParam == VK_SPACE && cfg.alt_space) {
2142             alt_state = 0;
2143             PostMessage(hwnd, WM_CHAR, ' ', 0);
2144             SendMessage (hwnd, WM_SYSCOMMAND, SC_KEYMENU, 0);
2145             return -1;
2146         }
2147         /* Control-Numlock for app-keypad mode switch */
2148         if (wParam == VK_PAUSE && shift_state == 2) {
2149             app_keypad_keys ^= 1;
2150             return 0;
2151         }
2152
2153         /* Nethack keypad */
2154         if (cfg.nethack_keypad && !left_alt) {
2155            switch(wParam) {
2156                case VK_NUMPAD1: *p++ = shift_state ? 'B': 'b'; return p-output;
2157                case VK_NUMPAD2: *p++ = shift_state ? 'J': 'j'; return p-output;
2158                case VK_NUMPAD3: *p++ = shift_state ? 'N': 'n'; return p-output;
2159                case VK_NUMPAD4: *p++ = shift_state ? 'H': 'h'; return p-output;
2160                case VK_NUMPAD5: *p++ = shift_state ? '.': '.'; return p-output;
2161                case VK_NUMPAD6: *p++ = shift_state ? 'L': 'l'; return p-output;
2162                case VK_NUMPAD7: *p++ = shift_state ? 'Y': 'y'; return p-output;
2163                case VK_NUMPAD8: *p++ = shift_state ? 'K': 'k'; return p-output;
2164                case VK_NUMPAD9: *p++ = shift_state ? 'U': 'u'; return p-output;
2165            }
2166         }
2167
2168         /* Application Keypad */
2169         if (!left_alt) {
2170            int xkey = 0;
2171
2172            if ( cfg.funky_type == 3 ||
2173               ( cfg.funky_type <= 1 &&
2174                app_keypad_keys && !cfg.no_applic_k)) switch(wParam) {
2175                case VK_EXECUTE: xkey = 'P'; break;
2176                case VK_DIVIDE:  xkey = 'Q'; break;
2177                case VK_MULTIPLY:xkey = 'R'; break;
2178                case VK_SUBTRACT:xkey = 'S'; break;
2179            }
2180            if(app_keypad_keys && !cfg.no_applic_k) switch(wParam) {
2181                case VK_NUMPAD0: xkey = 'p'; break;
2182                case VK_NUMPAD1: xkey = 'q'; break;
2183                case VK_NUMPAD2: xkey = 'r'; break;
2184                case VK_NUMPAD3: xkey = 's'; break;
2185                case VK_NUMPAD4: xkey = 't'; break;
2186                case VK_NUMPAD5: xkey = 'u'; break;
2187                case VK_NUMPAD6: xkey = 'v'; break;
2188                case VK_NUMPAD7: xkey = 'w'; break;
2189                case VK_NUMPAD8: xkey = 'x'; break;
2190                case VK_NUMPAD9: xkey = 'y'; break;
2191
2192                case VK_DECIMAL: xkey = 'n'; break;
2193                case VK_ADD:     if(cfg.funky_type==2) {
2194                                     if(shift_state) xkey = 'l';
2195                                     else            xkey = 'k';
2196                                 } else if(shift_state)  xkey = 'm';
2197                                   else                  xkey = 'l';
2198                                 break;
2199
2200                case VK_DIVIDE:  if(cfg.funky_type==2) xkey = 'o'; break;
2201                case VK_MULTIPLY:if(cfg.funky_type==2) xkey = 'j'; break;
2202                case VK_SUBTRACT:if(cfg.funky_type==2) xkey = 'm'; break;
2203
2204                case VK_RETURN:
2205                                 if (HIWORD(lParam)&KF_EXTENDED)
2206                                     xkey = 'M';
2207                                 break;
2208             }
2209             if(xkey)
2210             {
2211                 if (vt52_mode)
2212                 {
2213                     if (xkey>='P' && xkey<='S')
2214                         p += sprintf((char *)p, "\x1B%c", xkey);
2215                     else
2216                         p += sprintf((char *)p, "\x1B?%c", xkey);
2217                 }
2218                 else
2219                     p += sprintf((char *)p, "\x1BO%c", xkey);
2220                 return p - output;
2221             }
2222         }
2223
2224         if (wParam == VK_BACK && shift_state == 0 )     /* Backspace */
2225         {
2226             *p++ = (cfg.bksp_is_delete ? 0x7F : 0x08);
2227             return p-output;
2228         }
2229         if (wParam == VK_TAB && shift_state == 1 )      /* Shift tab */
2230         {
2231             *p++ = 0x1B; *p++ = '['; *p++ = 'Z'; return p - output;
2232         }
2233         if (wParam == VK_SPACE && shift_state == 2 )    /* Ctrl-Space */
2234         {
2235             *p++ = 0; return p - output;
2236         }
2237         if (wParam == VK_SPACE && shift_state == 3 )    /* Ctrl-Shift-Space */
2238         {
2239             *p++ = 160; return p - output;
2240         }
2241         if (wParam == VK_CANCEL && shift_state == 2 )   /* Ctrl-Break */
2242         {
2243             *p++ = 3; return p - output;
2244         }
2245         /* Control-2 to Control-8 are special */
2246         if (shift_state == 2 && wParam >= '2' && wParam <= '8')
2247         {
2248             *p++ = "\000\033\034\035\036\037\177"[wParam-'2'];
2249             return p - output;
2250         }
2251         if (shift_state == 2 && wParam == 0xBD) {
2252             *p++ = 0x1F;
2253             return p - output;
2254         }
2255         if (shift_state == 2 && wParam == 0xDF) {
2256             *p++ = 0x1C;
2257             return p - output;
2258         }
2259         if (shift_state == 0 && wParam == VK_RETURN && cr_lf_return) {
2260             *p++ = '\r'; *p++ = '\n';
2261             return p - output;
2262         }
2263
2264         /*
2265          * Next, all the keys that do tilde codes. (ESC '[' nn '~',
2266          * for integer decimal nn.)
2267          *
2268          * We also deal with the weird ones here. Linux VCs replace F1
2269          * to F5 by ESC [ [ A to ESC [ [ E. rxvt doesn't do _that_, but
2270          * does replace Home and End (1~ and 4~) by ESC [ H and ESC O w
2271          * respectively.
2272          */
2273         code = 0;
2274         switch (wParam) {
2275           case VK_F1: code = (keystate[VK_SHIFT] & 0x80 ? 23 : 11); break;
2276           case VK_F2: code = (keystate[VK_SHIFT] & 0x80 ? 24 : 12); break;
2277           case VK_F3: code = (keystate[VK_SHIFT] & 0x80 ? 25 : 13); break;
2278           case VK_F4: code = (keystate[VK_SHIFT] & 0x80 ? 26 : 14); break;
2279           case VK_F5: code = (keystate[VK_SHIFT] & 0x80 ? 28 : 15); break;
2280           case VK_F6: code = (keystate[VK_SHIFT] & 0x80 ? 29 : 17); break;
2281           case VK_F7: code = (keystate[VK_SHIFT] & 0x80 ? 31 : 18); break;
2282           case VK_F8: code = (keystate[VK_SHIFT] & 0x80 ? 32 : 19); break;
2283           case VK_F9: code = (keystate[VK_SHIFT] & 0x80 ? 33 : 20); break;
2284           case VK_F10: code = (keystate[VK_SHIFT] & 0x80 ? 34 : 21); break;
2285           case VK_F11: code = 23; break;
2286           case VK_F12: code = 24; break;
2287           case VK_F13: code = 25; break;
2288           case VK_F14: code = 26; break;
2289           case VK_F15: code = 28; break;
2290           case VK_F16: code = 29; break;
2291           case VK_F17: code = 31; break;
2292           case VK_F18: code = 32; break;
2293           case VK_F19: code = 33; break;
2294           case VK_F20: code = 34; break;
2295           case VK_HOME: code = 1; break;
2296           case VK_INSERT: code = 2; break;
2297           case VK_DELETE: code = 3; break;
2298           case VK_END: code = 4; break;
2299           case VK_PRIOR: code = 5; break;
2300           case VK_NEXT: code = 6; break;
2301         }
2302         /* Reorder edit keys to physical order */
2303         if (cfg.funky_type == 3 && code <= 6 ) code = "\0\2\1\4\5\3\6"[code];
2304
2305         if (cfg.funky_type == 1 && code >= 11 && code <= 15) {
2306             p += sprintf((char *)p, "\x1B[[%c", code + 'A' - 11);
2307             return p - output;
2308         }
2309         if (cfg.funky_type == 2 && code >= 11 && code <= 14) {
2310             if (vt52_mode)
2311                 p += sprintf((char *)p, "\x1B%c", code + 'P' - 11);
2312             else
2313                 p += sprintf((char *)p, "\x1BO%c", code + 'P' - 11);
2314             return p - output;
2315         }
2316         if (cfg.rxvt_homeend && (code == 1 || code == 4)) {
2317             p += sprintf((char *)p, code == 1 ? "\x1B[H" : "\x1BOw");
2318             return p - output;
2319         }
2320         if (code) {
2321             p += sprintf((char *)p, "\x1B[%d~", code);
2322             return p - output;
2323         }
2324
2325         /*
2326          * Now the remaining keys (arrows and Keypad 5. Keypad 5 for
2327          * some reason seems to send VK_CLEAR to Windows...).
2328          */
2329         {
2330             char xkey = 0;
2331             switch (wParam) {
2332                 case VK_UP:     xkey = 'A'; break;
2333                 case VK_DOWN:   xkey = 'B'; break;
2334                 case VK_RIGHT:  xkey = 'C'; break;
2335                 case VK_LEFT:   xkey = 'D'; break;
2336                 case VK_CLEAR:  xkey = 'G'; break;
2337             }
2338             if (xkey)
2339             {
2340                 if (vt52_mode)
2341                     p += sprintf((char *)p, "\x1B%c", xkey);
2342                 else if (app_cursor_keys && !cfg.no_applic_c)
2343                     p += sprintf((char *)p, "\x1BO%c", xkey);
2344                 else
2345                     p += sprintf((char *)p, "\x1B[%c", xkey);
2346                 return p - output;
2347             }
2348         }
2349
2350         /*
2351          * Finally, deal with Return ourselves. (Win95 seems to
2352          * foul it up when Alt is pressed, for some reason.)
2353          */
2354         if (wParam == VK_RETURN)       /* Return */
2355         {
2356             *p++ = 0x0D;
2357             return p-output;
2358         }
2359     }
2360
2361     /* Okay we've done everything interesting; let windows deal with
2362      * the boring stuff */
2363     {
2364         BOOL capsOn=keystate[VK_CAPITAL] !=0;
2365
2366         /* helg: clear CAPS LOCK state if caps lock switches to cyrillic */
2367         if(cfg.xlat_capslockcyr)
2368             keystate[VK_CAPITAL] = 0;
2369
2370         r = ToAsciiEx(wParam, scan, keystate, keys, 0, kbd_layout);
2371         if(r>0)
2372         {
2373             p = output;
2374             for(i=0; i<r; i++)
2375             {
2376                 unsigned char ch = (unsigned char)keys[i];
2377
2378                 if (compose_state==2 && (ch&0x80) == 0 && ch>' ') {
2379                     compose_char = ch;
2380                     compose_state ++;
2381                     continue;
2382                 }
2383                 if (compose_state==3 && (ch&0x80) == 0 && ch>' ') {
2384                     int nc;
2385                     compose_state = 0;
2386
2387                     if ((nc=check_compose(compose_char,ch)) == -1)
2388                     {
2389                         MessageBeep(MB_ICONHAND);
2390                         return 0;
2391                     }
2392                     *p++ = xlat_kbd2tty((unsigned char)nc);
2393                     return p-output;
2394                 }
2395
2396                 compose_state = 0;
2397
2398                 if( left_alt && key_down ) *p++ = '\033';
2399                 if (!key_down)
2400                     *p++ = ch;
2401                 else
2402                 {
2403                     if(capsOn)
2404                         ch = xlat_latkbd2win(ch);
2405                     *p++ = xlat_kbd2tty(ch);
2406                 }
2407             }
2408
2409             /* This is so the ALT-Numpad and dead keys work correctly. */
2410             keys[0] = 0;
2411
2412             return p-output;
2413         }
2414     }
2415
2416     /* ALT alone may or may not want to bring up the System menu */
2417     if (wParam == VK_MENU) {
2418         if (cfg.alt_only) {
2419             if (message == WM_SYSKEYDOWN)
2420                 alt_state = 1;
2421             else if (message == WM_SYSKEYUP && alt_state)
2422                 PostMessage(hwnd, WM_CHAR, ' ', 0);
2423             if (message == WM_SYSKEYUP)
2424                 alt_state = 0;
2425         } else
2426             return 0;
2427     }
2428
2429     return -1;
2430 }
2431
2432 void set_title (char *title) {
2433     sfree (window_name);
2434     window_name = smalloc(1+strlen(title));
2435     strcpy (window_name, title);
2436     if (cfg.win_name_always || !IsIconic(hwnd))
2437         SetWindowText (hwnd, title);
2438 }
2439
2440 void set_icon (char *title) {
2441     sfree (icon_name);
2442     icon_name = smalloc(1+strlen(title));
2443     strcpy (icon_name, title);
2444     if (!cfg.win_name_always && IsIconic(hwnd))
2445         SetWindowText (hwnd, title);
2446 }
2447
2448 void set_sbar (int total, int start, int page) {
2449     SCROLLINFO si;
2450
2451     if (!cfg.scrollbar) return;
2452
2453     si.cbSize = sizeof(si);
2454     si.fMask = SIF_ALL | SIF_DISABLENOSCROLL;
2455     si.nMin = 0;
2456     si.nMax = total - 1;
2457     si.nPage = page;
2458     si.nPos = start;
2459     if (hwnd)
2460         SetScrollInfo (hwnd, SB_VERT, &si, TRUE);
2461 }
2462
2463 Context get_ctx(void) {
2464     HDC hdc;
2465     if (hwnd) {
2466         hdc = GetDC (hwnd);
2467         if (hdc && pal)
2468             SelectPalette (hdc, pal, FALSE);
2469         return hdc;
2470     } else
2471         return NULL;
2472 }
2473
2474 void free_ctx (Context ctx) {
2475     SelectPalette (ctx, GetStockObject (DEFAULT_PALETTE), FALSE);
2476     ReleaseDC (hwnd, ctx);
2477 }
2478
2479 static void real_palette_set (int n, int r, int g, int b) {
2480     if (pal) {
2481         logpal->palPalEntry[n].peRed = r;
2482         logpal->palPalEntry[n].peGreen = g;
2483         logpal->palPalEntry[n].peBlue = b;
2484         logpal->palPalEntry[n].peFlags = PC_NOCOLLAPSE;
2485         colours[n] = PALETTERGB(r, g, b);
2486         SetPaletteEntries (pal, 0, NCOLOURS, logpal->palPalEntry);
2487     } else
2488         colours[n] = RGB(r, g, b);
2489 }
2490
2491 void palette_set (int n, int r, int g, int b) {
2492     static const int first[21] = {
2493         0, 2, 4, 6, 8, 10, 12, 14,
2494         1, 3, 5, 7, 9, 11, 13, 15,
2495         16, 17, 18, 20, 22
2496     };
2497     real_palette_set (first[n], r, g, b);
2498     if (first[n] >= 18)
2499         real_palette_set (first[n]+1, r, g, b);
2500     if (pal) {
2501         HDC hdc = get_ctx();
2502         UnrealizeObject (pal);
2503         RealizePalette (hdc);
2504         free_ctx (hdc);
2505     }
2506 }
2507
2508 void palette_reset (void) {
2509     int i;
2510
2511     for (i = 0; i < NCOLOURS; i++) {
2512         if (pal) {
2513             logpal->palPalEntry[i].peRed = defpal[i].rgbtRed;
2514             logpal->palPalEntry[i].peGreen = defpal[i].rgbtGreen;
2515             logpal->palPalEntry[i].peBlue = defpal[i].rgbtBlue;
2516             logpal->palPalEntry[i].peFlags = 0;
2517             colours[i] = PALETTERGB(defpal[i].rgbtRed,
2518                                     defpal[i].rgbtGreen,
2519                                     defpal[i].rgbtBlue);
2520         } else
2521             colours[i] = RGB(defpal[i].rgbtRed,
2522                              defpal[i].rgbtGreen,
2523                              defpal[i].rgbtBlue);
2524     }
2525
2526     if (pal) {
2527         HDC hdc;
2528         SetPaletteEntries (pal, 0, NCOLOURS, logpal->palPalEntry);
2529         hdc = get_ctx();
2530         RealizePalette (hdc);
2531         free_ctx (hdc);
2532     }
2533 }
2534
2535 void write_clip (void *data, int len, int must_deselect) {
2536     HGLOBAL clipdata;
2537     void *lock;
2538
2539     clipdata = GlobalAlloc (GMEM_DDESHARE | GMEM_MOVEABLE, len + 1);
2540     if (!clipdata)
2541         return;
2542     lock = GlobalLock (clipdata);
2543     if (!lock)
2544         return;
2545     memcpy (lock, data, len);
2546     ((unsigned char *) lock) [len] = 0;
2547     GlobalUnlock (clipdata);
2548
2549     if (!must_deselect)
2550         SendMessage (hwnd, WM_IGNORE_CLIP, TRUE, 0);
2551
2552     if (OpenClipboard (hwnd)) {
2553         EmptyClipboard();
2554         SetClipboardData (CF_TEXT, clipdata);
2555         CloseClipboard();
2556     } else
2557         GlobalFree (clipdata);
2558
2559     if (!must_deselect)
2560         SendMessage (hwnd, WM_IGNORE_CLIP, FALSE, 0);
2561 }
2562
2563 void get_clip (void **p, int *len) {
2564     static HGLOBAL clipdata = NULL;
2565
2566     if (!p) {
2567         if (clipdata)
2568             GlobalUnlock (clipdata);
2569         clipdata = NULL;
2570         return;
2571     } else {
2572         if (OpenClipboard (NULL)) {
2573             clipdata = GetClipboardData (CF_TEXT);
2574             CloseClipboard();
2575             if (clipdata) {
2576                 *p = GlobalLock (clipdata);
2577                 if (*p) {
2578                     *len = strlen(*p);
2579                     return;
2580                 }
2581             }
2582         }
2583     }
2584
2585     *p = NULL;
2586     *len = 0;
2587 }
2588
2589 /*
2590  * Move `lines' lines from position `from' to position `to' in the
2591  * window.
2592  */
2593 void optimised_move (int to, int from, int lines) {
2594     RECT r;
2595     int min, max;
2596
2597     min = (to < from ? to : from);
2598     max = to + from - min;
2599
2600     r.left = 0; r.right = cols * font_width;
2601     r.top = min * font_height; r.bottom = (max+lines) * font_height;
2602     ScrollWindow (hwnd, 0, (to - from) * font_height, &r, &r);
2603 }
2604
2605 /*
2606  * Print a message box and perform a fatal exit.
2607  */
2608 void fatalbox(char *fmt, ...) {
2609     va_list ap;
2610     char stuff[200];
2611
2612     va_start(ap, fmt);
2613     vsprintf(stuff, fmt, ap);
2614     va_end(ap);
2615     MessageBox(hwnd, stuff, "PuTTY Fatal Error", MB_ICONERROR | MB_OK);
2616     exit(1);
2617 }
2618
2619 /*
2620  * Beep.
2621  */
2622 void beep(int errorbeep) {
2623     static long last_beep = 0;
2624     long now, beep_diff;
2625
2626     now = GetTickCount();
2627     beep_diff = now-last_beep;
2628
2629     /* Make sure we only respond to one beep per packet or so */
2630     if (beep_diff>=0 && beep_diff<50)
2631         return;
2632
2633     if(errorbeep)
2634        MessageBeep(MB_ICONHAND);
2635     else
2636        MessageBeep(MB_OK);
2637
2638     last_beep = GetTickCount();
2639 }