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