window.c

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