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_IGNORE_CLIP:
1400         ignore_clip = wParam;          /* don't panic on DESTROYCLIPBOARD */
1401         break;
1402       case WM_DESTROYCLIPBOARD:
1403         if (!ignore_clip)
1404             term_deselect();
1405         ignore_clip = FALSE;
1406         return 0;
1407       case WM_PAINT:
1408         {
1409             PAINTSTRUCT p;
1410             HideCaret(hwnd);
1411             hdc = BeginPaint (hwnd, &p);
1412             if (pal) {
1413                 SelectPalette (hdc, pal, TRUE);
1414                 RealizePalette (hdc);
1415             }
1416             term_paint (hdc, p.rcPaint.left, p.rcPaint.top,
1417                         p.rcPaint.right, p.rcPaint.bottom);
1418             SelectObject (hdc, GetStockObject(SYSTEM_FONT));
1419             SelectObject (hdc, GetStockObject(WHITE_PEN));
1420             EndPaint (hwnd, &p);
1421             ShowCaret(hwnd);
1422         }
1423         return 0;
1424       case WM_NETEVENT:
1425         /* Notice we can get multiple netevents, FD_READ, FD_WRITE etc
1426          * but the only one that's likely to try to overload us is FD_READ.
1427          * This means buffering just one is fine.
1428          */
1429         if (pending_netevent)
1430             enact_pending_netevent();
1431
1432         pending_netevent = TRUE;
1433         pend_netevent_wParam=wParam;
1434         pend_netevent_lParam=lParam;
1435         time(&last_movement);
1436         return 0;
1437       case WM_SETFOCUS:
1438         has_focus = TRUE;
1439         CreateCaret(hwnd, caretbm, font_width, font_height);
1440         ShowCaret(hwnd);
1441         compose_state = 0;
1442         term_out();
1443         term_update();
1444         break;
1445       case WM_KILLFOCUS:
1446         show_mouseptr(1);
1447         has_focus = FALSE;
1448         DestroyCaret();
1449         term_out();
1450         term_update();
1451         break;
1452       case WM_IGNORE_SIZE:
1453         ignore_size = TRUE;            /* don't panic on next WM_SIZE msg */
1454         break;
1455       case WM_ENTERSIZEMOVE:
1456         EnableSizeTip(1);
1457         resizing = TRUE;
1458         need_backend_resize = FALSE;
1459         break;
1460       case WM_EXITSIZEMOVE:
1461         EnableSizeTip(0);
1462         resizing = FALSE;
1463         if (need_backend_resize)
1464             back->size();
1465         break;
1466       case WM_SIZING:
1467         {
1468             int width, height, w, h, ew, eh;
1469             LPRECT r = (LPRECT)lParam;
1470
1471             width = r->right - r->left - extra_width;
1472             height = r->bottom - r->top - extra_height;
1473             w = (width + font_width/2) / font_width; if (w < 1) w = 1;
1474             h = (height + font_height/2) / font_height; if (h < 1) h = 1;
1475             UpdateSizeTip(hwnd, w, h);
1476             ew = width - w * font_width;
1477             eh = height - h * font_height;
1478             if (ew != 0) {
1479                 if (wParam == WMSZ_LEFT ||
1480                     wParam == WMSZ_BOTTOMLEFT ||
1481                     wParam == WMSZ_TOPLEFT)
1482                     r->left += ew;
1483                 else
1484                     r->right -= ew;
1485             }
1486             if (eh != 0) {
1487                 if (wParam == WMSZ_TOP ||
1488                     wParam == WMSZ_TOPRIGHT ||
1489                     wParam == WMSZ_TOPLEFT)
1490                     r->top += eh;
1491                 else
1492                     r->bottom -= eh;
1493             }
1494             if (ew || eh)
1495                 return 1;
1496             else
1497                 return 0;
1498         }
1499         /* break;  (never reached) */
1500       case WM_SIZE:
1501         if (wParam == SIZE_MINIMIZED) {
1502             SetWindowText (hwnd,
1503                            cfg.win_name_always ? window_name : icon_name);
1504             break;
1505         }
1506         if (wParam == SIZE_RESTORED || wParam == SIZE_MAXIMIZED)
1507             SetWindowText (hwnd, window_name);
1508         if (!ignore_size) {
1509             int width, height, w, h;
1510 #if 0 /* we have fixed this using WM_SIZING now */
1511             int ew, eh;
1512 #endif
1513
1514             width = LOWORD(lParam);
1515             height = HIWORD(lParam);
1516             w = width / font_width; if (w < 1) w = 1;
1517             h = height / font_height; if (h < 1) h = 1;
1518 #if 0 /* we have fixed this using WM_SIZING now */
1519             ew = width - w * font_width;
1520             eh = height - h * font_height;
1521             if (ew != 0 || eh != 0) {
1522                 RECT r;
1523                 GetWindowRect (hwnd, &r);
1524                 SendMessage (hwnd, WM_IGNORE_SIZE, 0, 0);
1525                 SetWindowPos (hwnd, NULL, 0, 0,
1526                               r.right - r.left - ew, r.bottom - r.top - eh,
1527                               SWP_NOACTIVATE | SWP_NOMOVE | SWP_NOZORDER);
1528             }
1529 #endif
1530             if (w != cols || h != rows || just_reconfigged) {
1531                 term_invalidate();
1532                 term_size (h, w, cfg.savelines);
1533                 /*
1534                  * Don't call back->size in mid-resize. (To prevent
1535                  * massive numbers of resize events getting sent
1536                  * down the connection during an NT opaque drag.)
1537                  */
1538                 if (!resizing)
1539                     back->size();
1540                 else
1541                     need_backend_resize = TRUE;
1542                 just_reconfigged = FALSE;
1543             }
1544         }
1545         ignore_size = FALSE;
1546         return 0;
1547       case WM_VSCROLL:
1548         switch (LOWORD(wParam)) {
1549           case SB_BOTTOM: term_scroll(-1, 0); break;
1550           case SB_TOP: term_scroll(+1, 0); break;
1551           case SB_LINEDOWN: term_scroll (0, +1); break;
1552           case SB_LINEUP: term_scroll (0, -1); break;
1553           case SB_PAGEDOWN: term_scroll (0, +rows/2); break;
1554           case SB_PAGEUP: term_scroll (0, -rows/2); break;
1555           case SB_THUMBPOSITION: case SB_THUMBTRACK:
1556             term_scroll (1, HIWORD(wParam)); break;
1557         }
1558         break;
1559      case WM_PALETTECHANGED:
1560         if ((HWND) wParam != hwnd && pal != NULL) {
1561             HDC hdc = get_ctx();
1562             if (hdc) {
1563                 if (RealizePalette (hdc) > 0)
1564                     UpdateColors (hdc);
1565                 free_ctx (hdc);
1566             }
1567         }
1568         break;
1569       case WM_QUERYNEWPALETTE:
1570         if (pal != NULL) {
1571             HDC hdc = get_ctx();
1572             if (hdc) {
1573                 if (RealizePalette (hdc) > 0)
1574                     UpdateColors (hdc);
1575                 free_ctx (hdc);
1576                 return TRUE;
1577             }
1578         }
1579         return FALSE;
1580       case WM_KEYDOWN:
1581       case WM_SYSKEYDOWN:
1582       case WM_KEYUP:
1583       case WM_SYSKEYUP:
1584         /*
1585          * Add the scan code and keypress timing to the random
1586          * number noise.
1587          */
1588         noise_ultralight(lParam);
1589
1590         /*
1591          * We don't do TranslateMessage since it disassociates the
1592          * resulting CHAR message from the KEYDOWN that sparked it,
1593          * which we occasionally don't want. Instead, we process
1594          * KEYDOWN, and call the Win32 translator functions so that
1595          * we get the translations under _our_ control.
1596          */
1597         {
1598             unsigned char buf[20];
1599             int len;
1600
1601             if (wParam==VK_PROCESSKEY) {
1602                 MSG m;
1603                 m.hwnd = hwnd;
1604                 m.message = WM_KEYDOWN;
1605                 m.wParam = wParam;
1606                 m.lParam = lParam & 0xdfff;
1607                 TranslateMessage(&m);
1608             } else {
1609                 len = TranslateKey (message, wParam, lParam, buf);
1610                 if (len == -1)
1611                     return DefWindowProc (hwnd, message, wParam, lParam);
1612                 ldisc_send (buf, len);
1613
1614                 if (len > 0)
1615                     show_mouseptr(0);
1616             }
1617         }
1618         return 0;
1619       case WM_IME_CHAR:
1620         {
1621             unsigned char buf[2];
1622
1623             buf[1] = wParam;
1624             buf[0] = wParam >> 8;
1625             ldisc_send (buf, 2);
1626         }
1627       case WM_CHAR:
1628       case WM_SYSCHAR:
1629         /*
1630          * Nevertheless, we are prepared to deal with WM_CHAR
1631          * messages, should they crop up. So if someone wants to
1632          * post the things to us as part of a macro manoeuvre,
1633          * we're ready to cope.
1634          */
1635         {
1636             char c = xlat_kbd2tty((unsigned char)wParam);
1637             ldisc_send (&c, 1);
1638         }
1639         return 0;
1640     }
1641
1642     return DefWindowProc (hwnd, message, wParam, lParam);
1643 }
1644
1645 /*
1646  * Move the system caret. (We maintain one, even though it's
1647  * invisible, for the benefit of blind people: apparently some
1648  * helper software tracks the system caret, so we should arrange to
1649  * have one.)
1650  */
1651 void sys_cursor(int x, int y) {
1652     SetCaretPos(x * font_width, y * font_height);
1653 }
1654
1655 /*
1656  * Draw a line of text in the window, at given character
1657  * coordinates, in given attributes.
1658  *
1659  * We are allowed to fiddle with the contents of `text'.
1660  */
1661 void do_text (Context ctx, int x, int y, char *text, int len,
1662               unsigned long attr, int lattr) {
1663     COLORREF fg, bg, t;
1664     int nfg, nbg, nfont;
1665     HDC hdc = ctx;
1666     RECT line_box;
1667     int force_manual_underline = 0;
1668     int fnt_width = font_width*(1+(lattr!=LATTR_NORM));
1669     static int *IpDx = 0, IpDxLEN = 0;;
1670
1671     if (len>IpDxLEN || IpDx[0] != fnt_width) {
1672         int i;
1673         if (len>IpDxLEN) {
1674             sfree(IpDx);
1675             IpDx = smalloc((len+16)*sizeof(int));
1676             IpDxLEN = (len+16);
1677         }
1678         for(i=0; i<IpDxLEN; i++)
1679             IpDx[i] = fnt_width;
1680     }
1681
1682     x *= fnt_width;
1683     y *= font_height;
1684
1685     if ((attr & ATTR_ACTCURS) && cfg.cursor_type == 0) {
1686         attr &= (bold_mode == BOLD_COLOURS ? 0x300200 : 0x300300);
1687         attr ^= ATTR_CUR_XOR;
1688     }
1689
1690     nfont = 0;
1691     if (cfg.vtmode == VT_OEMONLY)
1692         nfont |= FONT_OEM;
1693
1694     /*
1695      * Map high-half characters in order to approximate ISO using
1696      * OEM character set. No characters are missing if the OEM codepage
1697      * is CP850.
1698      */
1699     if (nfont & FONT_OEM) {
1700         int i;
1701         for (i=0; i<len; i++)
1702             if (text[i] >= '\xA0' && text[i] <= '\xFF') {
1703 #if 0
1704                 /* This is CP850 ... perfect translation */
1705                 static const char oemhighhalf[] =
1706                     "\x20\xAD\xBD\x9C\xCF\xBE\xDD\xF5" /* A0-A7 */
1707                     "\xF9\xB8\xA6\xAE\xAA\xF0\xA9\xEE" /* A8-AF */
1708                     "\xF8\xF1\xFD\xFC\xEF\xE6\xF4\xFA" /* B0-B7 */
1709                     "\xF7\xFB\xA7\xAF\xAC\xAB\xF3\xA8" /* B8-BF */
1710                     "\xB7\xB5\xB6\xC7\x8E\x8F\x92\x80" /* C0-C7 */
1711                     "\xD4\x90\xD2\xD3\xDE\xD6\xD7\xD8" /* C8-CF */
1712                     "\xD1\xA5\xE3\xE0\xE2\xE5\x99\x9E" /* D0-D7 */
1713                     "\x9D\xEB\xE9\xEA\x9A\xED\xE8\xE1" /* D8-DF */
1714                     "\x85\xA0\x83\xC6\x84\x86\x91\x87" /* E0-E7 */
1715                     "\x8A\x82\x88\x89\x8D\xA1\x8C\x8B" /* E8-EF */
1716                     "\xD0\xA4\x95\xA2\x93\xE4\x94\xF6" /* F0-F7 */
1717                     "\x9B\x97\xA3\x96\x81\xEC\xE7\x98" /* F8-FF */
1718                     ;
1719 #endif
1720                 /* This is CP437 ... junk translation */
1721                 static const unsigned char oemhighhalf[] = {
1722                     0xff, 0xad, 0x9b, 0x9c, 0x6f, 0x9d, 0x7c, 0x15,
1723                     0x22, 0x43, 0xa6, 0xae, 0xaa, 0x2d, 0x52, 0xc4,
1724                     0xf8, 0xf1, 0xfd, 0x33, 0x27, 0xe6, 0x14, 0xfa,
1725                     0x2c, 0x31, 0xa7, 0xaf, 0xac, 0xab, 0x2f, 0xa8,
1726                     0x41, 0x41, 0x41, 0x41, 0x8e, 0x8f, 0x92, 0x80,
1727                     0x45, 0x90, 0x45, 0x45, 0x49, 0x49, 0x49, 0x49,
1728                     0x44, 0xa5, 0x4f, 0x4f, 0x4f, 0x4f, 0x99, 0x78,
1729                     0xed, 0x55, 0x55, 0x55, 0x9a, 0x59, 0x50, 0xe1,
1730                     0x85, 0xa0, 0x83, 0x61, 0x84, 0x86, 0x91, 0x87,
1731                     0x8a, 0x82, 0x88, 0x89, 0x8d, 0xa1, 0x8c, 0x8b,
1732                     0x0b, 0xa4, 0x95, 0xa2, 0x93, 0x6f, 0x94, 0xf6,
1733                     0xed, 0x97, 0xa3, 0x96, 0x81, 0x79, 0x70, 0x98
1734                 };
1735
1736                 text[i] = oemhighhalf[(unsigned char)text[i] - 0xA0];
1737             }
1738     }
1739
1740     if (attr & ATTR_LINEDRW) {
1741         int i;
1742         /* ISO 8859-1 */
1743         static const char poorman[] =
1744             "*#****\xB0\xB1**+++++-----++++|****\xA3\xB7";
1745
1746         /* CP437 */
1747         static const char oemmap_437[] =
1748             "\x04\xB1****\xF8\xF1**\xD9\xBF\xDA\xC0\xC5"
1749             "\xC4\xC4\xC4\xC4\xC4\xC3\xB4\xC1\xC2\xB3\xF3\xF2\xE3*\x9C\xFA";
1750
1751         /* CP850 */
1752         static const char oemmap_850[] =
1753             "\x04\xB1****\xF8\xF1**\xD9\xBF\xDA\xC0\xC5"
1754             "\xC4\xC4\xC4\xC4\xC4\xC3\xB4\xC1\xC2\xB3****\x9C\xFA";
1755
1756         /* Poor windows font ... eg: windows courier */
1757         static const char oemmap[] =
1758             "*\xB1****\xF8\xF1**\xD9\xBF\xDA\xC0\xC5"
1759             "\xC4\xC4\xC4\xC4\xC4\xC3\xB4\xC1\xC2\xB3****\x9C\xFA";
1760
1761         /*
1762          * Line drawing mapping: map ` thru ~ (0x60 thru 0x7E) to
1763          * VT100 line drawing chars; everything else stays normal.
1764          *
1765          * Actually '_' maps to space too, but that's done before.
1766          */
1767         switch (cfg.vtmode) {
1768           case VT_XWINDOWS:
1769             for (i=0; i<len; i++)
1770                 if (text[i] >= '\x60' && text[i] <= '\x7E')
1771                     text[i] += '\x01' - '\x60';
1772             break;
1773           case VT_OEMANSI:
1774             /* Make sure we actually have an OEM font */
1775             if (fonts[nfont|FONT_OEM]) {
1776           case VT_OEMONLY:
1777                 nfont |= FONT_OEM;
1778                 for (i=0; i<len; i++)
1779                     if (text[i] >= '\x60' && text[i] <= '\x7E')
1780                         text[i] = oemmap[(unsigned char)text[i] - 0x60];
1781                 break;
1782             }
1783           case VT_POORMAN:
1784             for (i=0; i<len; i++)
1785                 if (text[i] >= '\x60' && text[i] <= '\x7E')
1786                     text[i] = poorman[(unsigned char)text[i] - 0x60];
1787             break;
1788         }
1789     }
1790
1791     nfg = 2 * ((attr & ATTR_FGMASK) >> ATTR_FGSHIFT);
1792     nbg = 2 * ((attr & ATTR_BGMASK) >> ATTR_BGSHIFT);
1793     if (bold_mode == BOLD_FONT && (attr & ATTR_BOLD))
1794         nfont |= FONT_BOLD;
1795     if (und_mode == UND_FONT && (attr & ATTR_UNDER))
1796         nfont |= FONT_UNDERLINE;
1797     if (!fonts[nfont])
1798     {
1799         if (nfont&FONT_UNDERLINE)
1800             force_manual_underline = 1;
1801         /* Don't do the same for manual bold, it could be bad news. */
1802
1803         nfont &= ~(FONT_BOLD|FONT_UNDERLINE);
1804     }
1805     if (font_needs_hand_underlining && (attr & ATTR_UNDER))
1806         force_manual_underline = 1;
1807     if (attr & ATTR_REVERSE) {
1808         t = nfg; nfg = nbg; nbg = t;
1809     }
1810     if (bold_mode == BOLD_COLOURS && (attr & ATTR_BOLD))
1811         nfg++;
1812     if (bold_mode == BOLD_COLOURS && (attr & ATTR_BLINK))
1813         nbg++;
1814     fg = colours[nfg];
1815     bg = colours[nbg];
1816     SelectObject (hdc, fonts[nfont]);
1817     SetTextColor (hdc, fg);
1818     SetBkColor (hdc, bg);
1819     SetBkMode (hdc, OPAQUE);
1820     line_box.left   = x;
1821     line_box.top    = y;
1822     line_box.right  = x+fnt_width*len;
1823     line_box.bottom = y+font_height;
1824     ExtTextOut (hdc, x, y, ETO_CLIPPED|ETO_OPAQUE, &line_box, text, len, IpDx);
1825     if (bold_mode == BOLD_SHADOW && (attr & ATTR_BOLD)) {
1826         SetBkMode (hdc, TRANSPARENT);
1827
1828        /* GRR: This draws the character outside it's box and can leave
1829         * 'droppings' even with the clip box! I suppose I could loop it
1830         * one character at a time ... yuk.
1831         *
1832         * Or ... I could do a test print with "W", and use +1 or -1 for this
1833         * shift depending on if the leftmost column is blank...
1834         */
1835         ExtTextOut (hdc, x-1, y, ETO_CLIPPED, &line_box, text, len, IpDx);
1836     }
1837     if (force_manual_underline ||
1838             (und_mode == UND_LINE && (attr & ATTR_UNDER))) {
1839         HPEN oldpen;
1840         oldpen = SelectObject (hdc, CreatePen(PS_SOLID, 0, fg));
1841         MoveToEx (hdc, x, y+descent, NULL);
1842         LineTo (hdc, x+len*fnt_width, y+descent);
1843         oldpen = SelectObject (hdc, oldpen);
1844         DeleteObject (oldpen);
1845     }
1846     if ((attr & ATTR_PASCURS) && cfg.cursor_type == 0) {
1847         POINT pts[5];
1848         HPEN oldpen;
1849         pts[0].x = pts[1].x = pts[4].x = x;
1850         pts[2].x = pts[3].x = x+fnt_width-1;
1851         pts[0].y = pts[3].y = pts[4].y = y;
1852         pts[1].y = pts[2].y = y+font_height-1;
1853         oldpen = SelectObject (hdc, CreatePen(PS_SOLID, 0, colours[23]));
1854         Polyline (hdc, pts, 5);
1855         oldpen = SelectObject (hdc, oldpen);
1856         DeleteObject (oldpen);
1857     }
1858     if ((attr & (ATTR_ACTCURS | ATTR_PASCURS)) && cfg.cursor_type != 0) {
1859         int startx, starty, dx, dy, length, i;
1860         if (cfg.cursor_type == 1) {
1861             startx = x; starty = y+descent;
1862             dx = 1; dy = 0; length = fnt_width;
1863         } else {
1864             int xadjust = 0;
1865             if (attr & ATTR_RIGHTCURS)
1866                 xadjust = fnt_width-1;
1867             startx = x+xadjust; starty = y;
1868             dx = 0; dy = 1; length = font_height;
1869         }
1870         if (attr & ATTR_ACTCURS) {
1871             HPEN oldpen;
1872             oldpen = SelectObject (hdc, CreatePen(PS_SOLID, 0, colours[23]));
1873             MoveToEx (hdc, startx, starty, NULL);
1874             LineTo (hdc, startx+dx*length, starty+dy*length);
1875             oldpen = SelectObject (hdc, oldpen);
1876             DeleteObject (oldpen);
1877         } else {
1878             for (i = 0; i < length; i++) {
1879                 if (i % 2 == 0) {
1880                     SetPixel(hdc, startx, starty, colours[23]);
1881                 }
1882                 startx += dx; starty += dy;
1883             }
1884         }
1885     }
1886 }
1887
1888 static int check_compose(int first, int second) {
1889
1890     static char * composetbl[] = {
1891        "++#", "AA@", "(([", "//\\", "))]", "(-{", "-)}", "/^|", "!!¡", "C/¢",
1892        "C|¢", "L-£", "L=£", "XO¤", "X0¤", "Y-¥", "Y=¥", "||¦", "SO§", "S!§",
1893        "S0§", "\"\"¨", "CO©", "C0©", "A_ª", "<<«", ",-¬", "--", "RO®",
1894        "-^¯", "0^°", "+-±", "2^²", "3^³", "''´", "/Uµ", "P!¶", ".^·", ",,¸",
1895        "1^¹", "O_º", ">>»", "14¼", "12½", "34¾", "??¿", "`AÀ", "'AÁ", "^AÂ",
1896        "~AÃ", "\"AÄ", "*AÅ", "AEÆ", ",CÇ", "`EÈ", "'EÉ", "^EÊ", "\"EË",
1897        "`IÌ", "'IÍ", "^IÎ", "\"IÏ", "-DÐ", "~NÑ", "`OÒ", "'OÓ", "^OÔ",
1898        "~OÕ", "\"OÖ", "XX×", "/OØ", "`UÙ", "'UÚ", "^UÛ", "\"UÜ", "'YÝ",
1899        "HTÞ", "ssß", "`aà", "'aá", "^aâ", "~aã", "\"aä", "*aå", "aeæ", ",cç",
1900        "`eè", "'eé", "^eê", "\"eë", "`iì", "'ií", "^iî", "\"iï", "-dð", "~nñ",
1901        "`oò", "'oó", "^oô", "~oõ", "\"oö", ":-÷", "o/ø", "`uù", "'uú", "^uû",
1902        "\"uü", "'yý", "htþ", "\"yÿ",
1903     0};
1904
1905     char ** c;
1906     static int recurse = 0;
1907     int nc = -1;
1908
1909     for(c=composetbl; *c; c++) {
1910         if( (*c)[0] == first && (*c)[1] == second)
1911         {
1912             return (*c)[2] & 0xFF;
1913         }
1914     }
1915
1916     if(recurse==0)
1917     {
1918         recurse=1;
1919         nc = check_compose(second, first);
1920         if(nc == -1)
1921             nc = check_compose(toupper(first), toupper(second));
1922         if(nc == -1)
1923             nc = check_compose(toupper(second), toupper(first));
1924         recurse=0;
1925     }
1926     return nc;
1927 }
1928
1929
1930 /*
1931  * Translate a WM_(SYS)?KEY(UP|DOWN) message into a string of ASCII
1932  * codes. Returns number of bytes used or zero to drop the message
1933  * or -1 to forward the message to windows.
1934  */
1935 static int TranslateKey(UINT message, WPARAM wParam, LPARAM lParam,
1936                         unsigned char *output) {
1937     BYTE keystate[256];
1938     int  scan, left_alt = 0, key_down, shift_state;
1939     int  r, i, code;
1940     unsigned char * p = output;
1941     static int alt_state = 0;
1942
1943     HKL kbd_layout = GetKeyboardLayout(0);
1944
1945     static WORD keys[3];
1946     static int compose_char = 0;
1947     static WPARAM compose_key = 0;
1948
1949     r = GetKeyboardState(keystate);
1950     if (!r) memset(keystate, 0, sizeof(keystate));
1951     else
1952     {
1953 #if 0
1954        {  /* Tell us all about key events */
1955           static BYTE oldstate[256];
1956           static int first = 1;
1957           static int scan;
1958           int ch;
1959           if(first) memcpy(oldstate, keystate, sizeof(oldstate));
1960           first=0;
1961
1962           if ((HIWORD(lParam)&(KF_UP|KF_REPEAT))==KF_REPEAT) {
1963              debug(("+"));
1964           } else if ((HIWORD(lParam)&KF_UP) && scan==(HIWORD(lParam) & 0xFF) ) {
1965              debug((". U"));
1966           } else {
1967              debug((".\n"));
1968              if (wParam >= VK_F1 && wParam <= VK_F20 )
1969                 debug(("K_F%d", wParam+1-VK_F1));
1970              else switch(wParam)
1971              {
1972              case VK_SHIFT:   debug(("SHIFT")); break;
1973              case VK_CONTROL: debug(("CTRL")); break;
1974              case VK_MENU:    debug(("ALT")); break;
1975              default:         debug(("VK_%02x", wParam));
1976              }
1977              if(message == WM_SYSKEYDOWN || message == WM_SYSKEYUP)
1978                 debug(("*"));
1979              debug((", S%02x", scan=(HIWORD(lParam) & 0xFF) ));
1980
1981              ch = MapVirtualKeyEx(wParam, 2, kbd_layout);
1982              if (ch>=' ' && ch<='~') debug((", '%c'", ch));
1983              else if (ch)            debug((", $%02x", ch));
1984
1985              if (keys[0]) debug((", KB0=%02x", keys[0]));
1986              if (keys[1]) debug((", KB1=%02x", keys[1]));
1987              if (keys[2]) debug((", KB2=%02x", keys[2]));
1988
1989              if ( (keystate[VK_SHIFT]&0x80)!=0)     debug((", S"));
1990              if ( (keystate[VK_CONTROL]&0x80)!=0)   debug((", C"));
1991              if ( (HIWORD(lParam)&KF_EXTENDED) )    debug((", E"));
1992              if ( (HIWORD(lParam)&KF_UP) )          debug((", U"));
1993           }
1994
1995           if ((HIWORD(lParam)&(KF_UP|KF_REPEAT))==KF_REPEAT)
1996              ;
1997           else if ( (HIWORD(lParam)&KF_UP) )
1998              oldstate[wParam&0xFF] ^= 0x80;
1999           else
2000              oldstate[wParam&0xFF] ^= 0x81;
2001
2002           for(ch=0; ch<256; ch++)
2003              if (oldstate[ch] != keystate[ch])
2004                 debug((", M%02x=%02x", ch, keystate[ch]));
2005
2006           memcpy(oldstate, keystate, sizeof(oldstate));
2007        }
2008 #endif
2009
2010         if (wParam == VK_MENU && (HIWORD(lParam)&KF_EXTENDED)) {
2011             keystate[VK_RMENU] = keystate[VK_MENU];
2012         }
2013
2014         /* Note if AltGr was pressed and if it was used as a compose key */
2015         if (cfg.compose_key) {
2016             if (wParam == VK_MENU && (HIWORD(lParam)&KF_EXTENDED))
2017             {
2018                 if (!compose_state) compose_key = wParam;
2019             }
2020             if (wParam == VK_APPS && !compose_state)
2021                 compose_key = wParam;
2022
2023             if (wParam == compose_key)
2024             {
2025                 if (compose_state == 0 && (HIWORD(lParam)&(KF_UP|KF_REPEAT))==0)
2026                     compose_state = 1;
2027                 else if (compose_state == 1 && (HIWORD(lParam)&KF_UP))
2028                     compose_state = 2;
2029                 else
2030                     compose_state = 0;
2031             }
2032             else if (compose_state==1 && wParam != VK_CONTROL)
2033                 compose_state = 0;
2034         } else {
2035             compose_state = 0;
2036         }
2037
2038         /* Nastyness with NUMLock - Shift-NUMLock is left alone though */
2039         if ( (cfg.funky_type == 3 ||
2040               (cfg.funky_type <= 1 && app_keypad_keys && !cfg.no_applic_k))
2041               && wParam==VK_NUMLOCK && !(keystate[VK_SHIFT]&0x80)) {
2042
2043             wParam = VK_EXECUTE;
2044
2045             /* UnToggle NUMLock */
2046             if ((HIWORD(lParam)&(KF_UP|KF_REPEAT))==0)
2047                 keystate[VK_NUMLOCK] ^= 1;
2048         }
2049
2050         /* And write back the 'adjusted' state */
2051         SetKeyboardState (keystate);
2052     }
2053
2054     /* Disable Auto repeat if required */
2055     if (repeat_off && (HIWORD(lParam)&(KF_UP|KF_REPEAT))==KF_REPEAT)
2056        return 0;
2057
2058     if ((HIWORD(lParam)&KF_ALTDOWN) && (keystate[VK_RMENU]&0x80) == 0)
2059         left_alt = 1;
2060
2061     key_down = ((HIWORD(lParam)&KF_UP)==0);
2062
2063     /* Make sure Ctrl-ALT is not the same as AltGr for ToAscii */
2064     if (left_alt && (keystate[VK_CONTROL]&0x80))
2065         keystate[VK_MENU] = 0;
2066
2067     scan = (HIWORD(lParam) & (KF_UP | KF_EXTENDED | 0xFF));
2068     shift_state = ((keystate[VK_SHIFT]&0x80)!=0)
2069                 + ((keystate[VK_CONTROL]&0x80)!=0)*2;
2070
2071     /*
2072      * Record that we pressed key so the scroll window can be reset, but
2073      * be careful to avoid Shift-UP/Down
2074      */
2075     if( wParam != VK_SHIFT && wParam != VK_PRIOR && wParam != VK_NEXT ) {
2076         seen_key_event = 1;
2077     }
2078
2079     /* Make sure we're not pasting */
2080     if (key_down) term_nopaste();
2081
2082     if (compose_state>1 && left_alt) compose_state = 0;
2083
2084     /* Sanitize the number pad if not using a PC NumPad */
2085     if( left_alt || (app_keypad_keys && !cfg.no_applic_k
2086                      && cfg.funky_type != 2)
2087         || cfg.funky_type == 3 || cfg.nethack_keypad || compose_state )
2088     {
2089         if ((HIWORD(lParam)&KF_EXTENDED) == 0)
2090         {
2091             int nParam = 0;
2092             switch(wParam)
2093             {
2094             case VK_INSERT:     nParam = VK_NUMPAD0; break;
2095             case VK_END:        nParam = VK_NUMPAD1; break;
2096             case VK_DOWN:       nParam = VK_NUMPAD2; break;
2097             case VK_NEXT:       nParam = VK_NUMPAD3; break;
2098             case VK_LEFT:       nParam = VK_NUMPAD4; break;
2099             case VK_CLEAR:      nParam = VK_NUMPAD5; break;
2100             case VK_RIGHT:      nParam = VK_NUMPAD6; break;
2101             case VK_HOME:       nParam = VK_NUMPAD7; break;
2102             case VK_UP:         nParam = VK_NUMPAD8; break;
2103             case VK_PRIOR:      nParam = VK_NUMPAD9; break;
2104             case VK_DELETE:     nParam = VK_DECIMAL; break;
2105             }
2106             if (nParam)
2107             {
2108                 if (keystate[VK_NUMLOCK]&1) shift_state |= 1;
2109                 wParam = nParam;
2110             }
2111         }
2112     }
2113
2114     /* If a key is pressed and AltGr is not active */
2115     if (key_down && (keystate[VK_RMENU]&0x80) == 0 && !compose_state)
2116     {
2117         /* Okay, prepare for most alts then ...*/
2118         if (left_alt) *p++ = '\033';
2119
2120         /* Lets see if it's a pattern we know all about ... */
2121         if (wParam == VK_PRIOR && shift_state == 1) {
2122             SendMessage (hwnd, WM_VSCROLL, SB_PAGEUP, 0);
2123             return 0;
2124         }
2125         if (wParam == VK_NEXT && shift_state == 1) {
2126             SendMessage (hwnd, WM_VSCROLL, SB_PAGEDOWN, 0);
2127             return 0;
2128         }
2129         if (wParam == VK_INSERT && shift_state == 1) {
2130             term_mouse (MB_PASTE, MA_CLICK, 0, 0);
2131             term_mouse (MB_PASTE, MA_RELEASE, 0, 0);
2132             return 0;
2133         }
2134         if (left_alt && wParam == VK_F4 && cfg.alt_f4) {
2135             return -1;
2136         }
2137         if (left_alt && wParam == VK_SPACE && cfg.alt_space) {
2138             alt_state = 0;
2139             PostMessage(hwnd, WM_CHAR, ' ', 0);
2140             SendMessage (hwnd, WM_SYSCOMMAND, SC_KEYMENU, 0);
2141             return -1;
2142         }
2143         /* Control-Numlock for app-keypad mode switch */
2144         if (wParam == VK_PAUSE && shift_state == 2) {
2145             app_keypad_keys ^= 1;
2146             return 0;
2147         }
2148
2149         /* Nethack keypad */
2150         if (cfg.nethack_keypad && !left_alt) {
2151            switch(wParam) {
2152                case VK_NUMPAD1: *p++ = shift_state ? 'B': 'b'; return p-output;
2153                case VK_NUMPAD2: *p++ = shift_state ? 'J': 'j'; return p-output;
2154                case VK_NUMPAD3: *p++ = shift_state ? 'N': 'n'; return p-output;
2155                case VK_NUMPAD4: *p++ = shift_state ? 'H': 'h'; return p-output;
2156                case VK_NUMPAD5: *p++ = shift_state ? '.': '.'; return p-output;
2157                case VK_NUMPAD6: *p++ = shift_state ? 'L': 'l'; return p-output;
2158                case VK_NUMPAD7: *p++ = shift_state ? 'Y': 'y'; return p-output;
2159                case VK_NUMPAD8: *p++ = shift_state ? 'K': 'k'; return p-output;
2160                case VK_NUMPAD9: *p++ = shift_state ? 'U': 'u'; return p-output;
2161            }
2162         }
2163
2164         /* Application Keypad */
2165         if (!left_alt) {
2166            int xkey = 0;
2167
2168            if ( cfg.funky_type == 3 ||
2169               ( cfg.funky_type <= 1 &&
2170                app_keypad_keys && !cfg.no_applic_k)) switch(wParam) {
2171                case VK_EXECUTE: xkey = 'P'; break;
2172                case VK_DIVIDE:  xkey = 'Q'; break;
2173                case VK_MULTIPLY:xkey = 'R'; break;
2174                case VK_SUBTRACT:xkey = 'S'; break;
2175            }
2176            if(app_keypad_keys && !cfg.no_applic_k) switch(wParam) {
2177                case VK_NUMPAD0: xkey = 'p'; break;
2178                case VK_NUMPAD1: xkey = 'q'; break;
2179                case VK_NUMPAD2: xkey = 'r'; break;
2180                case VK_NUMPAD3: xkey = 's'; break;
2181                case VK_NUMPAD4: xkey = 't'; break;
2182                case VK_NUMPAD5: xkey = 'u'; break;
2183                case VK_NUMPAD6: xkey = 'v'; break;
2184                case VK_NUMPAD7: xkey = 'w'; break;
2185                case VK_NUMPAD8: xkey = 'x'; break;
2186                case VK_NUMPAD9: xkey = 'y'; break;
2187
2188                case VK_DECIMAL: xkey = 'n'; break;
2189                case VK_ADD:     if(cfg.funky_type==2) {
2190                                     if(shift_state) xkey = 'l';
2191                                     else            xkey = 'k';
2192                                 } else if(shift_state)  xkey = 'm';
2193                                   else                  xkey = 'l';
2194                                 break;
2195
2196                case VK_DIVIDE:  if(cfg.funky_type==2) xkey = 'o'; break;
2197                case VK_MULTIPLY:if(cfg.funky_type==2) xkey = 'j'; break;
2198                case VK_SUBTRACT:if(cfg.funky_type==2) xkey = 'm'; break;
2199
2200                case VK_RETURN:
2201                                 if (HIWORD(lParam)&KF_EXTENDED)
2202                                     xkey = 'M';
2203                                 break;
2204             }
2205             if(xkey)
2206             {
2207                 if (vt52_mode)
2208                 {
2209                     if (xkey>='P' && xkey<='S')
2210                         p += sprintf((char *)p, "\x1B%c", xkey);
2211                     else
2212                         p += sprintf((char *)p, "\x1B?%c", xkey);
2213                 }
2214                 else
2215                     p += sprintf((char *)p, "\x1BO%c", xkey);
2216                 return p - output;
2217             }
2218         }
2219
2220         if (wParam == VK_BACK && shift_state == 0 )     /* Backspace */
2221         {
2222             *p++ = (cfg.bksp_is_delete ? 0x7F : 0x08);
2223             return p-output;
2224         }
2225         if (wParam == VK_TAB && shift_state == 1 )      /* Shift tab */
2226         {
2227             *p++ = 0x1B; *p++ = '['; *p++ = 'Z'; return p - output;
2228         }
2229         if (wParam == VK_SPACE && shift_state == 2 )    /* Ctrl-Space */
2230         {
2231             *p++ = 0; return p - output;
2232         }
2233         if (wParam == VK_SPACE && shift_state == 3 )    /* Ctrl-Shift-Space */
2234         {
2235             *p++ = 160; return p - output;
2236         }
2237         if (wParam == VK_CANCEL && shift_state == 2 )   /* Ctrl-Break */
2238         {
2239             *p++ = 3; return p - output;
2240         }
2241         /* Control-2 to Control-8 are special */
2242         if (shift_state == 2 && wParam >= '2' && wParam <= '8')
2243         {
2244             *p++ = "\000\033\034\035\036\037\177"[wParam-'2'];
2245             return p - output;
2246         }
2247         if (shift_state == 2 && wParam == 0xBD) {
2248             *p++ = 0x1F;
2249             return p - output;
2250         }
2251         if (shift_state == 2 && wParam == 0xDF) {
2252             *p++ = 0x1C;
2253             return p - output;
2254         }
2255         if (shift_state == 0 && wParam == VK_RETURN && cr_lf_return) {
2256             *p++ = '\r'; *p++ = '\n';
2257             return p - output;
2258         }
2259
2260         /*
2261          * Next, all the keys that do tilde codes. (ESC '[' nn '~',
2262          * for integer decimal nn.)
2263          *
2264          * We also deal with the weird ones here. Linux VCs replace F1
2265          * to F5 by ESC [ [ A to ESC [ [ E. rxvt doesn't do _that_, but
2266          * does replace Home and End (1~ and 4~) by ESC [ H and ESC O w
2267          * respectively.
2268          */
2269         code = 0;
2270         switch (wParam) {
2271           case VK_F1: code = (keystate[VK_SHIFT] & 0x80 ? 23 : 11); break;
2272           case VK_F2: code = (keystate[VK_SHIFT] & 0x80 ? 24 : 12); break;
2273           case VK_F3: code = (keystate[VK_SHIFT] & 0x80 ? 25 : 13); break;
2274           case VK_F4: code = (keystate[VK_SHIFT] & 0x80 ? 26 : 14); break;
2275           case VK_F5: code = (keystate[VK_SHIFT] & 0x80 ? 28 : 15); break;
2276           case VK_F6: code = (keystate[VK_SHIFT] & 0x80 ? 29 : 17); break;
2277           case VK_F7: code = (keystate[VK_SHIFT] & 0x80 ? 31 : 18); break;
2278           case VK_F8: code = (keystate[VK_SHIFT] & 0x80 ? 32 : 19); break;
2279           case VK_F9: code = (keystate[VK_SHIFT] & 0x80 ? 33 : 20); break;
2280           case VK_F10: code = (keystate[VK_SHIFT] & 0x80 ? 34 : 21); break;
2281           case VK_F11: code = 23; break;
2282           case VK_F12: code = 24; break;
2283           case VK_F13: code = 25; break;
2284           case VK_F14: code = 26; break;
2285           case VK_F15: code = 28; break;
2286           case VK_F16: code = 29; break;
2287           case VK_F17: code = 31; break;
2288           case VK_F18: code = 32; break;
2289           case VK_F19: code = 33; break;
2290           case VK_F20: code = 34; break;
2291           case VK_HOME: code = 1; break;
2292           case VK_INSERT: code = 2; break;
2293           case VK_DELETE: code = 3; break;
2294           case VK_END: code = 4; break;
2295           case VK_PRIOR: code = 5; break;
2296           case VK_NEXT: code = 6; break;
2297         }
2298         /* Reorder edit keys to physical order */
2299         if (cfg.funky_type == 3 && code <= 6 ) code = "\0\2\1\4\5\3\6"[code];
2300
2301         if (cfg.funky_type == 1 && code >= 11 && code <= 15) {
2302             p += sprintf((char *)p, "\x1B[[%c", code + 'A' - 11);
2303             return p - output;
2304         }
2305         if (cfg.funky_type == 2 && code >= 11 && code <= 14) {
2306             if (vt52_mode)
2307                 p += sprintf((char *)p, "\x1B%c", code + 'P' - 11);
2308             else
2309                 p += sprintf((char *)p, "\x1BO%c", code + 'P' - 11);
2310             return p - output;
2311         }
2312         if (cfg.rxvt_homeend && (code == 1 || code == 4)) {
2313             p += sprintf((char *)p, code == 1 ? "\x1B[H" : "\x1BOw");
2314             return p - output;
2315         }
2316         if (code) {
2317             p += sprintf((char *)p, "\x1B[%d~", code);
2318             return p - output;
2319         }
2320
2321         /*
2322          * Now the remaining keys (arrows and Keypad 5. Keypad 5 for
2323          * some reason seems to send VK_CLEAR to Windows...).
2324          */
2325         {
2326             char xkey = 0;
2327             switch (wParam) {
2328                 case VK_UP:     xkey = 'A'; break;
2329                 case VK_DOWN:   xkey = 'B'; break;
2330                 case VK_RIGHT:  xkey = 'C'; break;
2331                 case VK_LEFT:   xkey = 'D'; break;
2332                 case VK_CLEAR:  xkey = 'G'; break;
2333             }
2334             if (xkey)
2335             {
2336                 if (vt52_mode)
2337                     p += sprintf((char *)p, "\x1B%c", xkey);
2338                 else if (app_cursor_keys && !cfg.no_applic_c)
2339                     p += sprintf((char *)p, "\x1BO%c", xkey);
2340                 else
2341                     p += sprintf((char *)p, "\x1B[%c", xkey);
2342                 return p - output;
2343             }
2344         }
2345
2346         /*
2347          * Finally, deal with Return ourselves. (Win95 seems to
2348          * foul it up when Alt is pressed, for some reason.)
2349          */
2350         if (wParam == VK_RETURN)       /* Return */
2351         {
2352             *p++ = 0x0D;
2353             return p-output;
2354         }
2355     }
2356
2357     /* Okay we've done everything interesting; let windows deal with
2358      * the boring stuff */
2359     {
2360         BOOL capsOn=keystate[VK_CAPITAL] !=0;
2361
2362         /* helg: clear CAPS LOCK state if caps lock switches to cyrillic */
2363         if(cfg.xlat_capslockcyr)
2364             keystate[VK_CAPITAL] = 0;
2365
2366         r = ToAsciiEx(wParam, scan, keystate, keys, 0, kbd_layout);
2367         if(r>0)
2368         {
2369             p = output;
2370             for(i=0; i<r; i++)
2371             {
2372                 unsigned char ch = (unsigned char)keys[i];
2373
2374                 if (compose_state==2 && (ch&0x80) == 0 && ch>' ') {
2375                     compose_char = ch;
2376                     compose_state ++;
2377                     continue;
2378                 }
2379                 if (compose_state==3 && (ch&0x80) == 0 && ch>' ') {
2380                     int nc;
2381                     compose_state = 0;
2382
2383                     if ((nc=check_compose(compose_char,ch)) == -1)
2384                     {
2385                         MessageBeep(MB_ICONHAND);
2386                         return 0;
2387                     }
2388                     *p++ = xlat_kbd2tty((unsigned char)nc);
2389                     return p-output;
2390                 }
2391
2392                 compose_state = 0;
2393
2394                 if( left_alt && key_down ) *p++ = '\033';
2395                 if (!key_down)
2396                     *p++ = ch;
2397                 else
2398                 {
2399                     if(capsOn)
2400                         ch = xlat_latkbd2win(ch);
2401                     *p++ = xlat_kbd2tty(ch);
2402                 }
2403             }
2404
2405             /* This is so the ALT-Numpad and dead keys work correctly. */
2406             keys[0] = 0;
2407
2408             return p-output;
2409         }
2410     }
2411
2412     /* ALT alone may or may not want to bring up the System menu */
2413     if (wParam == VK_MENU) {
2414         if (cfg.alt_only) {
2415             if (message == WM_SYSKEYDOWN)
2416                 alt_state = 1;
2417             else if (message == WM_SYSKEYUP && alt_state)
2418                 PostMessage(hwnd, WM_CHAR, ' ', 0);
2419             if (message == WM_SYSKEYUP)
2420                 alt_state = 0;
2421         } else
2422             return 0;
2423     }
2424
2425     return -1;
2426 }
2427
2428 void set_title (char *title) {
2429     sfree (window_name);
2430     window_name = smalloc(1+strlen(title));
2431     strcpy (window_name, title);
2432     if (cfg.win_name_always || !IsIconic(hwnd))
2433         SetWindowText (hwnd, title);
2434 }
2435
2436 void set_icon (char *title) {
2437     sfree (icon_name);
2438     icon_name = smalloc(1+strlen(title));
2439     strcpy (icon_name, title);
2440     if (!cfg.win_name_always && IsIconic(hwnd))
2441         SetWindowText (hwnd, title);
2442 }
2443
2444 void set_sbar (int total, int start, int page) {
2445     SCROLLINFO si;
2446
2447     if (!cfg.scrollbar) return;
2448
2449     si.cbSize = sizeof(si);
2450     si.fMask = SIF_ALL | SIF_DISABLENOSCROLL;
2451     si.nMin = 0;
2452     si.nMax = total - 1;
2453     si.nPage = page;
2454     si.nPos = start;
2455     if (hwnd)
2456         SetScrollInfo (hwnd, SB_VERT, &si, TRUE);
2457 }
2458
2459 Context get_ctx(void) {
2460     HDC hdc;
2461     if (hwnd) {
2462         hdc = GetDC (hwnd);
2463         if (hdc && pal)
2464             SelectPalette (hdc, pal, FALSE);
2465         return hdc;
2466     } else
2467         return NULL;
2468 }
2469
2470 void free_ctx (Context ctx) {
2471     SelectPalette (ctx, GetStockObject (DEFAULT_PALETTE), FALSE);
2472     ReleaseDC (hwnd, ctx);
2473 }
2474
2475 static void real_palette_set (int n, int r, int g, int b) {
2476     if (pal) {
2477         logpal->palPalEntry[n].peRed = r;
2478         logpal->palPalEntry[n].peGreen = g;
2479         logpal->palPalEntry[n].peBlue = b;
2480         logpal->palPalEntry[n].peFlags = PC_NOCOLLAPSE;
2481         colours[n] = PALETTERGB(r, g, b);
2482         SetPaletteEntries (pal, 0, NCOLOURS, logpal->palPalEntry);
2483     } else
2484         colours[n] = RGB(r, g, b);
2485 }
2486
2487 void palette_set (int n, int r, int g, int b) {
2488     static const int first[21] = {
2489         0, 2, 4, 6, 8, 10, 12, 14,
2490         1, 3, 5, 7, 9, 11, 13, 15,
2491         16, 17, 18, 20, 22
2492     };
2493     real_palette_set (first[n], r, g, b);
2494     if (first[n] >= 18)
2495         real_palette_set (first[n]+1, r, g, b);
2496     if (pal) {
2497         HDC hdc = get_ctx();
2498         UnrealizeObject (pal);
2499         RealizePalette (hdc);
2500         free_ctx (hdc);
2501     }
2502 }
2503
2504 void palette_reset (void) {
2505     int i;
2506
2507     for (i = 0; i < NCOLOURS; i++) {
2508         if (pal) {
2509             logpal->palPalEntry[i].peRed = defpal[i].rgbtRed;
2510             logpal->palPalEntry[i].peGreen = defpal[i].rgbtGreen;
2511             logpal->palPalEntry[i].peBlue = defpal[i].rgbtBlue;
2512             logpal->palPalEntry[i].peFlags = 0;
2513             colours[i] = PALETTERGB(defpal[i].rgbtRed,
2514                                     defpal[i].rgbtGreen,
2515                                     defpal[i].rgbtBlue);
2516         } else
2517             colours[i] = RGB(defpal[i].rgbtRed,
2518                              defpal[i].rgbtGreen,
2519                              defpal[i].rgbtBlue);
2520     }
2521
2522     if (pal) {
2523         HDC hdc;
2524         SetPaletteEntries (pal, 0, NCOLOURS, logpal->palPalEntry);
2525         hdc = get_ctx();
2526         RealizePalette (hdc);
2527         free_ctx (hdc);
2528     }
2529 }
2530
2531 void write_clip (void *data, int len, int must_deselect) {
2532     HGLOBAL clipdata;
2533     void *lock;
2534
2535     clipdata = GlobalAlloc (GMEM_DDESHARE | GMEM_MOVEABLE, len + 1);
2536     if (!clipdata)
2537         return;
2538     lock = GlobalLock (clipdata);
2539     if (!lock)
2540         return;
2541     memcpy (lock, data, len);
2542     ((unsigned char *) lock) [len] = 0;
2543     GlobalUnlock (clipdata);
2544
2545     if (!must_deselect)
2546         SendMessage (hwnd, WM_IGNORE_CLIP, TRUE, 0);
2547
2548     if (OpenClipboard (hwnd)) {
2549         EmptyClipboard();
2550         SetClipboardData (CF_TEXT, clipdata);
2551         CloseClipboard();
2552     } else
2553         GlobalFree (clipdata);
2554
2555     if (!must_deselect)
2556         SendMessage (hwnd, WM_IGNORE_CLIP, FALSE, 0);
2557 }
2558
2559 void get_clip (void **p, int *len) {
2560     static HGLOBAL clipdata = NULL;
2561
2562     if (!p) {
2563         if (clipdata)
2564             GlobalUnlock (clipdata);
2565         clipdata = NULL;
2566         return;
2567     } else {
2568         if (OpenClipboard (NULL)) {
2569             clipdata = GetClipboardData (CF_TEXT);
2570             CloseClipboard();
2571             if (clipdata) {
2572                 *p = GlobalLock (clipdata);
2573                 if (*p) {
2574                     *len = strlen(*p);
2575                     return;
2576                 }
2577             }
2578         }
2579     }
2580
2581     *p = NULL;
2582     *len = 0;
2583 }
2584
2585 /*
2586  * Move `lines' lines from position `from' to position `to' in the
2587  * window.
2588  */
2589 void optimised_move (int to, int from, int lines) {
2590     RECT r;
2591     int min, max;
2592
2593     min = (to < from ? to : from);
2594     max = to + from - min;
2595
2596     r.left = 0; r.right = cols * font_width;
2597     r.top = min * font_height; r.bottom = (max+lines) * font_height;
2598     ScrollWindow (hwnd, 0, (to - from) * font_height, &r, &r);
2599 }
2600
2601 /*
2602  * Print a message box and perform a fatal exit.
2603  */
2604 void fatalbox(char *fmt, ...) {
2605     va_list ap;
2606     char stuff[200];
2607
2608     va_start(ap, fmt);
2609     vsprintf(stuff, fmt, ap);
2610     va_end(ap);
2611     MessageBox(hwnd, stuff, "PuTTY Fatal Error", MB_ICONERROR | MB_OK);
2612     exit(1);
2613 }
2614
2615 /*
2616  * Beep.
2617  */
2618 void beep(int errorbeep) {
2619     static long last_beep = 0;
2620     long now, beep_diff;
2621
2622     now = GetTickCount();
2623     beep_diff = now-last_beep;
2624
2625     /* Make sure we only respond to one beep per packet or so */
2626     if (beep_diff>=0 && beep_diff<50)
2627         return;
2628
2629     if(errorbeep)
2630        MessageBeep(MB_ICONHAND);
2631     else
2632        MessageBeep(MB_OK);
2633
2634     last_beep = GetTickCount();
2635 }