window.c

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