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