window.c

   1 #include <windows.h>
   2 #include <imm.h>
   3 #include <commctrl.h>
   4 #include <richedit.h>
   5 #include <mmsystem.h>
   6 #ifndef AUTO_WINSOCK
   7 #ifdef WINSOCK_TWO
   8 #include <winsock2.h>
   9 #else
  10 #include <winsock.h>
  11 #endif
  12 #endif
  13
  14 #include <stdio.h>
  15 #include <stdlib.h>
  16 #include <ctype.h>
  17 #include <time.h>
  18 #include <assert.h>
  19
  20 #define PUTTY_DO_GLOBALS               /* actually _define_ globals */
  21 #include "putty.h"
  22 #include "winstuff.h"
  23 #include "storage.h"
  24 #include "win_res.h"
  25
  26 #define IDM_SHOWLOG   0x0010
  27 #define IDM_NEWSESS   0x0020
  28 #define IDM_DUPSESS   0x0030
  29 #define IDM_RECONF    0x0040
  30 #define IDM_CLRSB     0x0050
  31 #define IDM_RESET     0x0060
  32 #define IDM_TEL_AYT   0x0070
  33 #define IDM_TEL_BRK   0x0080
  34 #define IDM_TEL_SYNCH 0x0090
  35 #define IDM_TEL_EC    0x00a0
  36 #define IDM_TEL_EL    0x00b0
  37 #define IDM_TEL_GA    0x00c0
  38 #define IDM_TEL_NOP   0x00d0
  39 #define IDM_TEL_ABORT 0x00e0
  40 #define IDM_TEL_AO    0x00f0
  41 #define IDM_TEL_IP    0x0100
  42 #define IDM_TEL_SUSP  0x0110
  43 #define IDM_TEL_EOR   0x0120
  44 #define IDM_TEL_EOF   0x0130
  45 #define IDM_ABOUT     0x0140
  46 #define IDM_SAVEDSESS 0x0150
  47 #define IDM_COPYALL   0x0160
  48 #define IDM_FULLSCREEN  0x0170
  49
  50 #define IDM_SESSLGP   0x0250           /* log type printable */
  51 #define IDM_SESSLGA   0x0260           /* log type all chars */
  52 #define IDM_SESSLGE   0x0270           /* log end */
  53 #define IDM_SAVED_MIN 0x1000
  54 #define IDM_SAVED_MAX 0x2000
  55
  56 #define WM_IGNORE_CLIP (WM_XUSER + 2)
  57
  58 /* Needed for Chinese support and apparently not always defined. */
  59 #ifndef VK_PROCESSKEY
  60 #define VK_PROCESSKEY 0xE5
  61 #endif
  62
  63 /* Needed for mouse wheel support and not defined in earlier SDKs. */
  64 #ifndef WM_MOUSEWHEEL
  65 #define WM_MOUSEWHEEL 0x020A
  66 #endif
  67
  68 static LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM);
  69 static int TranslateKey(UINT message, WPARAM wParam, LPARAM lParam,
  70                         unsigned char *output);
  71 static void cfgtopalette(void);
  72 static void init_palette(void);
  73 static void init_fonts(int, int);
  74 static void another_font(int);
  75 static void deinit_fonts(void);
  76
  77 /* Window layout information */
  78 static void reset_window(int);
  79 static int full_screen = 0;
  80 static int extra_width, extra_height;
  81 static int font_width, font_height, font_dualwidth;
  82 static int offset_width, offset_height;
  83 static int was_zoomed = 0;
  84 static int prev_rows, prev_cols;
  85
  86 static int pending_netevent = 0;
  87 static WPARAM pend_netevent_wParam = 0;
  88 static LPARAM pend_netevent_lParam = 0;
  89 static void enact_pending_netevent(void);
  90 static void flash_window(int mode);
  91 static void flip_full_screen(void);
  92
  93 static time_t last_movement = 0;
  94
  95 #define FONT_NORMAL 0
  96 #define FONT_BOLD 1
  97 #define FONT_UNDERLINE 2
  98 #define FONT_BOLDUND 3
  99 #define FONT_WIDE       0x04
 100 #define FONT_HIGH       0x08
 101 #define FONT_NARROW     0x10
 102
 103 #define FONT_OEM        0x20
 104 #define FONT_OEMBOLD    0x21
 105 #define FONT_OEMUND     0x22
 106 #define FONT_OEMBOLDUND 0x23
 107
 108 #define FONT_MAXNO      0x2F
 109 #define FONT_SHIFT      5
 110 static HFONT fonts[FONT_MAXNO];
 111 static LOGFONT lfont;
 112 static int fontflag[FONT_MAXNO];
 113 static enum {
 114     BOLD_COLOURS, BOLD_SHADOW, BOLD_FONT
 115 } bold_mode;
 116 static enum {
 117     UND_LINE, UND_FONT
 118 } und_mode;
 119 static int descent;
 120
 121 #define NCOLOURS 24
 122 static COLORREF colours[NCOLOURS];
 123 static HPALETTE pal;
 124 static LPLOGPALETTE logpal;
 125 static RGBTRIPLE defpal[NCOLOURS];
 126
 127 static HWND hwnd;
 128
 129 static HBITMAP caretbm;
 130
 131 static int dbltime, lasttime, lastact;
 132 static Mouse_Button lastbtn;
 133
 134 /* this allows xterm-style mouse handling. */
 135 static int send_raw_mouse = 0;
 136 static int wheel_accumulator = 0;
 137
 138 static char *window_name, *icon_name;
 139
 140 static int compose_state = 0;
 141
 142 static OSVERSIONINFO osVersion;
 143
 144 /* Dummy routine, only required in plink. */
 145 void ldisc_update(int echo, int edit)
 146 {
 147 }
 148
 149 int WINAPI WinMain(HINSTANCE inst, HINSTANCE prev, LPSTR cmdline, int show)
 150 {
 151     static char appname[] = "PuTTY";
 152     WORD winsock_ver;
 153     WSADATA wsadata;
 154     WNDCLASS wndclass;
 155     MSG msg;
 156     int guess_width, guess_height;
 157
 158     hinst = inst;
 159     flags = FLAG_VERBOSE | FLAG_INTERACTIVE;
 160
 161     winsock_ver = MAKEWORD(1, 1);
 162     if (WSAStartup(winsock_ver, &wsadata)) {
 163         MessageBox(NULL, "Unable to initialise WinSock", "WinSock Error",
 164                    MB_OK | MB_ICONEXCLAMATION);
 165         return 1;
 166     }
 167     if (LOBYTE(wsadata.wVersion) != 1 || HIBYTE(wsadata.wVersion) != 1) {
 168         MessageBox(NULL, "WinSock version is incompatible with 1.1",
 169                    "WinSock Error", MB_OK | MB_ICONEXCLAMATION);
 170         WSACleanup();
 171         return 1;
 172     }
 173     /* WISHLIST: maybe allow config tweaking even if winsock not present? */
 174     sk_init();
 175
 176     InitCommonControls();
 177
 178     /* Ensure a Maximize setting in Explorer doesn't maximise the
 179      * config box. */
 180     defuse_showwindow();
 181
 182     {
 183         ZeroMemory(&osVersion, sizeof(osVersion));
 184         osVersion.dwOSVersionInfoSize = sizeof (OSVERSIONINFO);
 185         if (!GetVersionEx ( (OSVERSIONINFO *) &osVersion)) {
 186             MessageBox(NULL, "Windows refuses to report a version",
 187                        "PuTTY Fatal Error", MB_OK | MB_ICONEXCLAMATION);
 188             return 1;
 189         }
 190     }
 191
 192     /*
 193      * Process the command line.
 194      */
 195     {
 196         char *p;
 197
 198         default_protocol = DEFAULT_PROTOCOL;
 199         default_port = DEFAULT_PORT;
 200         cfg.logtype = LGTYP_NONE;
 201
 202         do_defaults(NULL, &cfg);
 203
 204         p = cmdline;
 205         while (*p && isspace(*p))
 206             p++;
 207
 208         /*
 209          * Process command line options first. Yes, this can be
 210          * done better, and it will be as soon as I have the
 211          * energy...
 212          */
 213         while (*p == '-') {
 214             char *q = p + strcspn(p, " \t");
 215             p++;
 216             if (q == p + 3 &&
 217                 tolower(p[0]) == 's' &&
 218                 tolower(p[1]) == 's' && tolower(p[2]) == 'h') {
 219                 default_protocol = cfg.protocol = PROT_SSH;
 220                 default_port = cfg.port = 22;
 221             } else if (q == p + 7 &&
 222                        tolower(p[0]) == 'c' &&
 223                        tolower(p[1]) == 'l' &&
 224                        tolower(p[2]) == 'e' &&
 225                        tolower(p[3]) == 'a' &&
 226                        tolower(p[4]) == 'n' &&
 227                        tolower(p[5]) == 'u' && tolower(p[6]) == 'p') {
 228                 /*
 229                  * `putty -cleanup'. Remove all registry entries
 230                  * associated with PuTTY, and also find and delete
 231                  * the random seed file.
 232                  */
 233                 if (MessageBox(NULL,
 234                                "This procedure will remove ALL Registry\n"
 235                                "entries associated with PuTTY, and will\n"
 236                                "also remove the PuTTY random seed file.\n"
 237                                "\n"
 238                                "THIS PROCESS WILL DESTROY YOUR SAVED\n"
 239                                "SESSIONS. Are you really sure you want\n"
 240                                "to continue?",
 241                                "PuTTY Warning",
 242                                MB_YESNO | MB_ICONWARNING) == IDYES) {
 243                     cleanup_all();
 244                 }
 245                 exit(0);
 246             }
 247             p = q + strspn(q, " \t");
 248         }
 249
 250         /*
 251          * An initial @ means to activate a saved session.
 252          */
 253         if (*p == '@') {
 254             int i = strlen(p);
 255             while (i > 1 && isspace(p[i - 1]))
 256                 i--;
 257             p[i] = '\0';
 258             do_defaults(p + 1, &cfg);
 259             if (!*cfg.host && !do_config()) {
 260                 WSACleanup();
 261                 return 0;
 262             }
 263         } else if (*p == '&') {
 264             /*
 265              * An initial & means we've been given a command line
 266              * containing the hex value of a HANDLE for a file
 267              * mapping object, which we must then extract as a
 268              * config.
 269              */
 270             HANDLE filemap;
 271             Config *cp;
 272             if (sscanf(p + 1, "%p", &filemap) == 1 &&
 273                 (cp = MapViewOfFile(filemap, FILE_MAP_READ,
 274                                     0, 0, sizeof(Config))) != NULL) {
 275                 cfg = *cp;
 276                 UnmapViewOfFile(cp);
 277                 CloseHandle(filemap);
 278             } else if (!do_config()) {
 279                 WSACleanup();
 280                 return 0;
 281             }
 282         } else if (*p) {
 283             char *q = p;
 284             /*
 285              * If the hostname starts with "telnet:", set the
 286              * protocol to Telnet and process the string as a
 287              * Telnet URL.
 288              */
 289             if (!strncmp(q, "telnet:", 7)) {
 290                 char c;
 291
 292                 q += 7;
 293                 if (q[0] == '/' && q[1] == '/')
 294                     q += 2;
 295                 cfg.protocol = PROT_TELNET;
 296                 p = q;
 297                 while (*p && *p != ':' && *p != '/')
 298                     p++;
 299                 c = *p;
 300                 if (*p)
 301                     *p++ = '\0';
 302                 if (c == ':')
 303                     cfg.port = atoi(p);
 304                 else
 305                     cfg.port = -1;
 306                 strncpy(cfg.host, q, sizeof(cfg.host) - 1);
 307                 cfg.host[sizeof(cfg.host) - 1] = '\0';
 308             } else {
 309                 while (*p && !isspace(*p))
 310                     p++;
 311                 if (*p)
 312                     *p++ = '\0';
 313                 strncpy(cfg.host, q, sizeof(cfg.host) - 1);
 314                 cfg.host[sizeof(cfg.host) - 1] = '\0';
 315                 while (*p && isspace(*p))
 316                     p++;
 317                 if (*p)
 318                     cfg.port = atoi(p);
 319                 else
 320                     cfg.port = -1;
 321             }
 322         } else {
 323             if (!do_config()) {
 324                 WSACleanup();
 325                 return 0;
 326             }
 327         }
 328
 329         /*
 330          * Trim leading whitespace off the hostname if it's there.
 331          */
 332         {
 333             int space = strspn(cfg.host, " \t");
 334             memmove(cfg.host, cfg.host+space, 1+strlen(cfg.host)-space);
 335         }
 336
 337         /* See if host is of the form user@host */
 338         if (cfg.host[0] != '\0') {
 339             char *atsign = strchr(cfg.host, '@');
 340             /* Make sure we're not overflowing the user field */
 341             if (atsign) {
 342                 if (atsign - cfg.host < sizeof cfg.username) {
 343                     strncpy(cfg.username, cfg.host, atsign - cfg.host);
 344                     cfg.username[atsign - cfg.host] = '\0';
 345                 }
 346                 memmove(cfg.host, atsign + 1, 1 + strlen(atsign + 1));
 347             }
 348         }
 349
 350         /*
 351          * Trim a colon suffix off the hostname if it's there.
 352          */
 353         cfg.host[strcspn(cfg.host, ":")] = '\0';
 354     }
 355
 356     /*
 357      * Select protocol. This is farmed out into a table in a
 358      * separate file to enable an ssh-free variant.
 359      */
 360     {
 361         int i;
 362         back = NULL;
 363         for (i = 0; backends[i].backend != NULL; i++)
 364             if (backends[i].protocol == cfg.protocol) {
 365                 back = backends[i].backend;
 366                 break;
 367             }
 368         if (back == NULL) {
 369             MessageBox(NULL, "Unsupported protocol number found",
 370                        "PuTTY Internal Error", MB_OK | MB_ICONEXCLAMATION);
 371             WSACleanup();
 372             return 1;
 373         }
 374     }
 375
 376     /* Check for invalid Port number (i.e. zero) */
 377     if (cfg.port == 0) {
 378         MessageBox(NULL, "Invalid Port Number",
 379                    "PuTTY Internal Error", MB_OK | MB_ICONEXCLAMATION);
 380         WSACleanup();
 381         return 1;
 382     }
 383
 384     if (!prev) {
 385         wndclass.style = 0;
 386         wndclass.lpfnWndProc = WndProc;
 387         wndclass.cbClsExtra = 0;
 388         wndclass.cbWndExtra = 0;
 389         wndclass.hInstance = inst;
 390         wndclass.hIcon = LoadIcon(inst, MAKEINTRESOURCE(IDI_MAINICON));
 391         wndclass.hCursor = LoadCursor(NULL, IDC_IBEAM);
 392         wndclass.hbrBackground = NULL;
 393         wndclass.lpszMenuName = NULL;
 394         wndclass.lpszClassName = appname;
 395
 396         RegisterClass(&wndclass);
 397     }
 398
 399     hwnd = NULL;
 400
 401     savelines = cfg.savelines;
 402     term_init();
 403
 404     cfgtopalette();
 405
 406     /*
 407      * Guess some defaults for the window size. This all gets
 408      * updated later, so we don't really care too much. However, we
 409      * do want the font width/height guesses to correspond to a
 410      * large font rather than a small one...
 411      */
 412
 413     font_width = 10;
 414     font_height = 20;
 415     extra_width = 25;
 416     extra_height = 28;
 417     term_size(cfg.height, cfg.width, cfg.savelines);
 418     guess_width = extra_width + font_width * cols;
 419     guess_height = extra_height + font_height * rows;
 420     {
 421         RECT r;
 422         HWND w = GetDesktopWindow();
 423         GetWindowRect(w, &r);
 424         if (guess_width > r.right - r.left)
 425             guess_width = r.right - r.left;
 426         if (guess_height > r.bottom - r.top)
 427             guess_height = r.bottom - r.top;
 428     }
 429
 430     {
 431         int winmode = WS_OVERLAPPEDWINDOW | WS_VSCROLL;
 432         int exwinmode = 0;
 433         if (!cfg.scrollbar)
 434             winmode &= ~(WS_VSCROLL);
 435         if (cfg.resize_action == RESIZE_DISABLED)
 436             winmode &= ~(WS_THICKFRAME | WS_MAXIMIZEBOX);
 437         if (cfg.alwaysontop)
 438             exwinmode |= WS_EX_TOPMOST;
 439         if (cfg.sunken_edge)
 440             exwinmode |= WS_EX_CLIENTEDGE;
 441         hwnd = CreateWindowEx(exwinmode, appname, appname,
 442                               winmode, CW_USEDEFAULT, CW_USEDEFAULT,
 443                               guess_width, guess_height,
 444                               NULL, NULL, inst, NULL);
 445     }
 446
 447     /*
 448      * Initialise the fonts, simultaneously correcting the guesses
 449      * for font_{width,height}.
 450      */
 451     init_fonts(0,0);
 452
 453     /*
 454      * Correct the guesses for extra_{width,height}.
 455      */
 456     {
 457         RECT cr, wr;
 458         GetWindowRect(hwnd, &wr);
 459         GetClientRect(hwnd, &cr);
 460         offset_width = offset_height = cfg.window_border;
 461         extra_width = wr.right - wr.left - cr.right + cr.left + offset_width*2;
 462         extra_height = wr.bottom - wr.top - cr.bottom + cr.top +offset_height*2;
 463     }
 464
 465     /*
 466      * Resize the window, now we know what size we _really_ want it
 467      * to be.
 468      */
 469     guess_width = extra_width + font_width * cols;
 470     guess_height = extra_height + font_height * rows;
 471     SetWindowPos(hwnd, NULL, 0, 0, guess_width, guess_height,
 472                  SWP_NOMOVE | SWP_NOREDRAW | SWP_NOZORDER);
 473
 474     /*
 475      * Set up a caret bitmap, with no content.
 476      */
 477     {
 478         char *bits;
 479         int size = (font_width + 15) / 16 * 2 * font_height;
 480         bits = smalloc(size);
 481         memset(bits, 0, size);
 482         caretbm = CreateBitmap(font_width, font_height, 1, 1, bits);
 483         sfree(bits);
 484     }
 485     CreateCaret(hwnd, caretbm, font_width, font_height);
 486
 487     /*
 488      * Initialise the scroll bar.
 489      */
 490     {
 491         SCROLLINFO si;
 492
 493         si.cbSize = sizeof(si);
 494         si.fMask = SIF_ALL | SIF_DISABLENOSCROLL;
 495         si.nMin = 0;
 496         si.nMax = rows - 1;
 497         si.nPage = rows;
 498         si.nPos = 0;
 499         SetScrollInfo(hwnd, SB_VERT, &si, FALSE);
 500     }
 501
 502     /*
 503      * Start up the telnet connection.
 504      */
 505     {
 506         char *error;
 507         char msg[1024], *title;
 508         char *realhost;
 509
 510         error = back->init(cfg.host, cfg.port, &realhost);
 511         if (error) {
 512             sprintf(msg, "Unable to open connection to\n"
 513                     "%.800s\n" "%s", cfg.host, error);
 514             MessageBox(NULL, msg, "PuTTY Error", MB_ICONERROR | MB_OK);
 515             return 0;
 516         }
 517         window_name = icon_name = NULL;
 518         if (*cfg.wintitle) {
 519             title = cfg.wintitle;
 520         } else {
 521             sprintf(msg, "%s - PuTTY", realhost);
 522             title = msg;
 523         }
 524         sfree(realhost);
 525         set_title(title);
 526         set_icon(title);
 527     }
 528
 529     session_closed = FALSE;
 530
 531     /*
 532      * Prepare the mouse handler.
 533      */
 534     lastact = MA_NOTHING;
 535     lastbtn = MBT_NOTHING;
 536     dbltime = GetDoubleClickTime();
 537
 538     /*
 539      * Set up the session-control options on the system menu.
 540      */
 541     {
 542         HMENU m = GetSystemMenu(hwnd, FALSE);
 543         HMENU p, s;
 544         int i;
 545
 546         AppendMenu(m, MF_SEPARATOR, 0, 0);
 547         if (cfg.protocol == PROT_TELNET) {
 548             p = CreateMenu();
 549             AppendMenu(p, MF_ENABLED, IDM_TEL_AYT, "Are You There");
 550             AppendMenu(p, MF_ENABLED, IDM_TEL_BRK, "Break");
 551             AppendMenu(p, MF_ENABLED, IDM_TEL_SYNCH, "Synch");
 552             AppendMenu(p, MF_SEPARATOR, 0, 0);
 553             AppendMenu(p, MF_ENABLED, IDM_TEL_EC, "Erase Character");
 554             AppendMenu(p, MF_ENABLED, IDM_TEL_EL, "Erase Line");
 555             AppendMenu(p, MF_ENABLED, IDM_TEL_GA, "Go Ahead");
 556             AppendMenu(p, MF_ENABLED, IDM_TEL_NOP, "No Operation");
 557             AppendMenu(p, MF_SEPARATOR, 0, 0);
 558             AppendMenu(p, MF_ENABLED, IDM_TEL_ABORT, "Abort Process");
 559             AppendMenu(p, MF_ENABLED, IDM_TEL_AO, "Abort Output");
 560             AppendMenu(p, MF_ENABLED, IDM_TEL_IP, "Interrupt Process");
 561             AppendMenu(p, MF_ENABLED, IDM_TEL_SUSP, "Suspend Process");
 562             AppendMenu(p, MF_SEPARATOR, 0, 0);
 563             AppendMenu(p, MF_ENABLED, IDM_TEL_EOR, "End Of Record");
 564             AppendMenu(p, MF_ENABLED, IDM_TEL_EOF, "End Of File");
 565             AppendMenu(m, MF_POPUP | MF_ENABLED, (UINT) p,
 566                        "Telnet Command");
 567             AppendMenu(m, MF_SEPARATOR, 0, 0);
 568         }
 569         AppendMenu(m, MF_ENABLED, IDM_SHOWLOG, "&Event Log");
 570         AppendMenu(m, MF_SEPARATOR, 0, 0);
 571         AppendMenu(m, MF_ENABLED, IDM_NEWSESS, "Ne&w Session...");
 572         AppendMenu(m, MF_ENABLED, IDM_DUPSESS, "&Duplicate Session");
 573         s = CreateMenu();
 574         get_sesslist(TRUE);
 575         for (i = 1; i < ((nsessions < 256) ? nsessions : 256); i++)
 576             AppendMenu(s, MF_ENABLED, IDM_SAVED_MIN + (16 * i),
 577                        sessions[i]);
 578         AppendMenu(m, MF_POPUP | MF_ENABLED, (UINT) s, "Sa&ved Sessions");
 579         AppendMenu(m, MF_ENABLED, IDM_RECONF, "Chan&ge Settings...");
 580         AppendMenu(m, MF_SEPARATOR, 0, 0);
 581         AppendMenu(m, MF_ENABLED, IDM_COPYALL, "C&opy All to Clipboard");
 582         AppendMenu(m, MF_ENABLED, IDM_CLRSB, "C&lear Scrollback");
 583         AppendMenu(m, MF_ENABLED, IDM_RESET, "Rese&t Terminal");
 584         AppendMenu(m, MF_SEPARATOR, 0, 0);
 585         AppendMenu(m, MF_ENABLED, IDM_FULLSCREEN, "&Full Screen");
 586         AppendMenu(m, MF_SEPARATOR, 0, 0);
 587         AppendMenu(m, MF_ENABLED, IDM_ABOUT, "&About PuTTY");
 588     }
 589
 590     /*
 591      * Finally show the window!
 592      */
 593     ShowWindow(hwnd, show);
 594     SetForegroundWindow(hwnd);
 595
 596     /*
 597      * Open the initial log file if there is one.
 598      */
 599     logfopen();
 600
 601     /*
 602      * Set the palette up.
 603      */
 604     pal = NULL;
 605     logpal = NULL;
 606     init_palette();
 607
 608     has_focus = (GetForegroundWindow() == hwnd);
 609     UpdateWindow(hwnd);
 610
 611     if (GetMessage(&msg, NULL, 0, 0) == 1) {
 612         int timer_id = 0, long_timer = 0;
 613
 614         while (msg.message != WM_QUIT) {
 615             /* Sometimes DispatchMessage calls routines that use their own
 616              * GetMessage loop, setup this timer so we get some control back.
 617              *
 618              * Also call term_update() from the timer so that if the host
 619              * is sending data flat out we still do redraws.
 620              */
 621             if (timer_id && long_timer) {
 622                 KillTimer(hwnd, timer_id);
 623                 long_timer = timer_id = 0;
 624             }
 625             if (!timer_id)
 626                 timer_id = SetTimer(hwnd, 1, 20, NULL);
 627             if (!(IsWindow(logbox) && IsDialogMessage(logbox, &msg)))
 628                 DispatchMessage(&msg);
 629
 630             /* Make sure we blink everything that needs it. */
 631             term_blink(0);
 632
 633             /* Send the paste buffer if there's anything to send */
 634             term_paste();
 635
 636             /* If there's nothing new in the queue then we can do everything
 637              * we've delayed, reading the socket, writing, and repainting
 638              * the window.
 639              */
 640             if (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))
 641                 continue;
 642
 643             if (pending_netevent) {
 644                 enact_pending_netevent();
 645
 646                 /* Force the cursor blink on */
 647                 term_blink(1);
 648
 649                 if (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))
 650                     continue;
 651             }
 652
 653             /* Okay there is now nothing to do so we make sure the screen is
 654              * completely up to date then tell windows to call us in a little
 655              * while.
 656              */
 657             if (timer_id) {
 658                 KillTimer(hwnd, timer_id);
 659                 timer_id = 0;
 660             }
 661             HideCaret(hwnd);
 662             term_out();
 663             term_update();
 664             ShowCaret(hwnd);
 665
 666             flash_window(1);           /* maintain */
 667
 668             if (in_vbell)
 669                 /* Hmm, term_update didn't want to do an update too soon ... */
 670                 timer_id = SetTimer(hwnd, 1, 50, NULL);
 671             else if (!has_focus)
 672                 timer_id = SetTimer(hwnd, 1, 500, NULL);
 673             else
 674                 timer_id = SetTimer(hwnd, 1, 100, NULL);
 675             long_timer = 1;
 676
 677             /* There's no point rescanning everything in the message queue
 678              * so we do an apparently unnecessary wait here
 679              */
 680             WaitMessage();
 681             if (GetMessage(&msg, NULL, 0, 0) != 1)
 682                 break;
 683         }
 684     }
 685
 686     /*
 687      * Clean up.
 688      */
 689     deinit_fonts();
 690     sfree(logpal);
 691     if (pal)
 692         DeleteObject(pal);
 693     WSACleanup();
 694
 695     if (cfg.protocol == PROT_SSH) {
 696         random_save_seed();
 697 #ifdef MSCRYPTOAPI
 698         crypto_wrapup();
 699 #endif
 700     }
 701
 702     return msg.wParam;
 703 }
 704
 705 /*
 706  * Set up, or shut down, an AsyncSelect. Called from winnet.c.
 707  */
 708 char *do_select(SOCKET skt, int startup)
 709 {
 710     int msg, events;
 711     if (startup) {
 712         msg = WM_NETEVENT;
 713         events = (FD_CONNECT | FD_READ | FD_WRITE |
 714                   FD_OOB | FD_CLOSE | FD_ACCEPT);
 715     } else {
 716         msg = events = 0;
 717     }
 718     if (!hwnd)
 719         return "do_select(): internal error (hwnd==NULL)";
 720     if (WSAAsyncSelect(skt, hwnd, msg, events) == SOCKET_ERROR) {
 721         switch (WSAGetLastError()) {
 722           case WSAENETDOWN:
 723             return "Network is down";
 724           default:
 725             return "WSAAsyncSelect(): unknown error";
 726         }
 727     }
 728     return NULL;
 729 }
 730
 731 /*
 732  * set or clear the "raw mouse message" mode
 733  */
 734 void set_raw_mouse_mode(int activate)
 735 {
 736     send_raw_mouse = activate;
 737     SetCursor(LoadCursor(NULL, activate ? IDC_ARROW : IDC_IBEAM));
 738 }
 739
 740 /*
 741  * Print a message box and close the connection.
 742  */
 743 void connection_fatal(char *fmt, ...)
 744 {
 745     va_list ap;
 746     char stuff[200];
 747
 748     va_start(ap, fmt);
 749     vsprintf(stuff, fmt, ap);
 750     va_end(ap);
 751     MessageBox(hwnd, stuff, "PuTTY Fatal Error", MB_ICONERROR | MB_OK);
 752     if (cfg.close_on_exit == COE_ALWAYS)
 753         PostQuitMessage(1);
 754     else {
 755         session_closed = TRUE;
 756         SetWindowText(hwnd, "PuTTY (inactive)");
 757     }
 758 }
 759
 760 /*
 761  * Actually do the job requested by a WM_NETEVENT
 762  */
 763 static void enact_pending_netevent(void)
 764 {
 765     static int reentering = 0;
 766     extern int select_result(WPARAM, LPARAM);
 767     int ret;
 768
 769     if (reentering)
 770         return;                        /* don't unpend the pending */
 771
 772     pending_netevent = FALSE;
 773
 774     reentering = 1;
 775     ret = select_result(pend_netevent_wParam, pend_netevent_lParam);
 776     reentering = 0;
 777
 778     if (ret == 0 && !session_closed) {
 779         /* Abnormal exits will already have set session_closed and taken
 780          * appropriate action. */
 781         if (cfg.close_on_exit == COE_ALWAYS ||
 782             cfg.close_on_exit == COE_NORMAL) PostQuitMessage(0);
 783         else {
 784             session_closed = TRUE;
 785             SetWindowText(hwnd, "PuTTY (inactive)");
 786             MessageBox(hwnd, "Connection closed by remote host",
 787                        "PuTTY", MB_OK | MB_ICONINFORMATION);
 788         }
 789     }
 790 }
 791
 792 /*
 793  * Copy the colour palette from the configuration data into defpal.
 794  * This is non-trivial because the colour indices are different.
 795  */
 796 static void cfgtopalette(void)
 797 {
 798     int i;
 799     static const int ww[] = {
 800         6, 7, 8, 9, 10, 11, 12, 13,
 801         14, 15, 16, 17, 18, 19, 20, 21,
 802         0, 1, 2, 3, 4, 4, 5, 5
 803     };
 804
 805     for (i = 0; i < 24; i++) {
 806         int w = ww[i];
 807         defpal[i].rgbtRed = cfg.colours[w][0];
 808         defpal[i].rgbtGreen = cfg.colours[w][1];
 809         defpal[i].rgbtBlue = cfg.colours[w][2];
 810     }
 811 }
 812
 813 /*
 814  * Set up the colour palette.
 815  */
 816 static void init_palette(void)
 817 {
 818     int i;
 819     HDC hdc = GetDC(hwnd);
 820     if (hdc) {
 821         if (cfg.try_palette && GetDeviceCaps(hdc, RASTERCAPS) & RC_PALETTE) {
 822             logpal = smalloc(sizeof(*logpal)
 823                              - sizeof(logpal->palPalEntry)
 824                              + NCOLOURS * sizeof(PALETTEENTRY));
 825             logpal->palVersion = 0x300;
 826             logpal->palNumEntries = NCOLOURS;
 827             for (i = 0; i < NCOLOURS; i++) {
 828                 logpal->palPalEntry[i].peRed = defpal[i].rgbtRed;
 829                 logpal->palPalEntry[i].peGreen = defpal[i].rgbtGreen;
 830                 logpal->palPalEntry[i].peBlue = defpal[i].rgbtBlue;
 831                 logpal->palPalEntry[i].peFlags = PC_NOCOLLAPSE;
 832             }
 833             pal = CreatePalette(logpal);
 834             if (pal) {
 835                 SelectPalette(hdc, pal, FALSE);
 836                 RealizePalette(hdc);
 837                 SelectPalette(hdc, GetStockObject(DEFAULT_PALETTE), FALSE);
 838             }
 839         }
 840         ReleaseDC(hwnd, hdc);
 841     }
 842     if (pal)
 843         for (i = 0; i < NCOLOURS; i++)
 844             colours[i] = PALETTERGB(defpal[i].rgbtRed,
 845                                     defpal[i].rgbtGreen,
 846                                     defpal[i].rgbtBlue);
 847     else
 848         for (i = 0; i < NCOLOURS; i++)
 849             colours[i] = RGB(defpal[i].rgbtRed,
 850                              defpal[i].rgbtGreen, defpal[i].rgbtBlue);
 851 }
 852
 853 /*
 854  * Initialise all the fonts we will need initially. There may be as many as
 855  * three or as few as one.  The other (poentially) twentyone fonts are done
 856  * if/when they are needed.
 857  *
 858  * We also:
 859  *
 860  * - check the font width and height, correcting our guesses if
 861  *   necessary.
 862  *
 863  * - verify that the bold font is the same width as the ordinary
 864  *   one, and engage shadow bolding if not.
 865  *
 866  * - verify that the underlined font is the same width as the
 867  *   ordinary one (manual underlining by means of line drawing can
 868  *   be done in a pinch).
 869  */
 870 static void init_fonts(int pick_width, int pick_height)
 871 {
 872     TEXTMETRIC tm;
 873     CPINFO cpinfo;
 874     int fontsize[3];
 875     int i;
 876     HDC hdc;
 877     int fw_dontcare, fw_bold;
 878
 879     for (i = 0; i < FONT_MAXNO; i++)
 880         fonts[i] = NULL;
 881
 882     bold_mode = cfg.bold_colour ? BOLD_COLOURS : BOLD_FONT;
 883     und_mode = UND_FONT;
 884
 885     if (cfg.fontisbold) {
 886         fw_dontcare = FW_BOLD;
 887         fw_bold = FW_HEAVY;
 888     } else {
 889         fw_dontcare = FW_DONTCARE;
 890         fw_bold = FW_BOLD;
 891     }
 892
 893     hdc = GetDC(hwnd);
 894
 895     if (pick_height)
 896         font_height = pick_height;
 897     else {
 898         font_height = cfg.fontheight;
 899         if (font_height > 0) {
 900             font_height =
 901                 -MulDiv(font_height, GetDeviceCaps(hdc, LOGPIXELSY), 72);
 902         }
 903     }
 904     font_width = pick_width;
 905
 906 #define f(i,c,w,u) \
 907     fonts[i] = CreateFont (font_height, font_width, 0, 0, w, FALSE, u, FALSE, \
 908                            c, OUT_DEFAULT_PRECIS, \
 909                            CLIP_DEFAULT_PRECIS, DEFAULT_QUALITY, \
 910                            FIXED_PITCH | FF_DONTCARE, cfg.font)
 911
 912     f(FONT_NORMAL, cfg.fontcharset, fw_dontcare, FALSE);
 913
 914     lfont.lfHeight = font_height;
 915     lfont.lfWidth = font_width;
 916     lfont.lfEscapement = 0;
 917     lfont.lfOrientation  = 0;
 918     lfont.lfWeight  = fw_dontcare;
 919     lfont.lfItalic = FALSE;
 920     lfont.lfUnderline = FALSE;
 921     lfont.lfStrikeOut = FALSE;
 922     lfont.lfCharSet = cfg.fontcharset;
 923     lfont.lfOutPrecision = OUT_DEFAULT_PRECIS;
 924     lfont.lfClipPrecision = CLIP_DEFAULT_PRECIS;
 925     lfont.lfQuality = DEFAULT_QUALITY;
 926     lfont.lfPitchAndFamily = FIXED_PITCH | FF_DONTCARE;
 927     strncpy(lfont.lfFaceName, cfg.font, LF_FACESIZE);
 928
 929     SelectObject(hdc, fonts[FONT_NORMAL]);
 930     GetTextMetrics(hdc, &tm);
 931
 932     if (pick_width == 0 || pick_height == 0) {
 933         font_height = tm.tmHeight;
 934         font_width = tm.tmAveCharWidth;
 935     }
 936     font_dualwidth = (tm.tmAveCharWidth != tm.tmMaxCharWidth);
 937
 938 #ifdef RDB_DEBUG_PATCH
 939     debug(23, "Primary font H=%d, AW=%d, MW=%d",
 940             tm.tmHeight, tm.tmAveCharWidth, tm.tmMaxCharWidth);
 941 #endif
 942
 943     {
 944         CHARSETINFO info;
 945         DWORD cset = tm.tmCharSet;
 946         memset(&info, 0xFF, sizeof(info));
 947
 948         /* !!! Yes the next line is right */
 949         if (cset == OEM_CHARSET)
 950             font_codepage = GetOEMCP();
 951         else
 952             if (TranslateCharsetInfo
 953                 ((DWORD *) cset, &info, TCI_SRCCHARSET)) font_codepage =
 954                 info.ciACP;
 955         else
 956             font_codepage = -1;
 957
 958         GetCPInfo(font_codepage, &cpinfo);
 959         dbcs_screenfont = (cpinfo.MaxCharSize > 1);
 960     }
 961
 962     f(FONT_UNDERLINE, cfg.fontcharset, fw_dontcare, TRUE);
 963
 964     /*
 965      * Some fonts, e.g. 9-pt Courier, draw their underlines
 966      * outside their character cell. We successfully prevent
 967      * screen corruption by clipping the text output, but then
 968      * we lose the underline completely. Here we try to work
 969      * out whether this is such a font, and if it is, we set a
 970      * flag that causes underlines to be drawn by hand.
 971      *
 972      * Having tried other more sophisticated approaches (such
 973      * as examining the TEXTMETRIC structure or requesting the
 974      * height of a string), I think we'll do this the brute
 975      * force way: we create a small bitmap, draw an underlined
 976      * space on it, and test to see whether any pixels are
 977      * foreground-coloured. (Since we expect the underline to
 978      * go all the way across the character cell, we only search
 979      * down a single column of the bitmap, half way across.)
 980      */
 981     {
 982         HDC und_dc;
 983         HBITMAP und_bm, und_oldbm;
 984         int i, gotit;
 985         COLORREF c;
 986
 987         und_dc = CreateCompatibleDC(hdc);
 988         und_bm = CreateCompatibleBitmap(hdc, font_width, font_height);
 989         und_oldbm = SelectObject(und_dc, und_bm);
 990         SelectObject(und_dc, fonts[FONT_UNDERLINE]);
 991         SetTextAlign(und_dc, TA_TOP | TA_LEFT | TA_NOUPDATECP);
 992         SetTextColor(und_dc, RGB(255, 255, 255));
 993         SetBkColor(und_dc, RGB(0, 0, 0));
 994         SetBkMode(und_dc, OPAQUE);
 995         ExtTextOut(und_dc, 0, 0, ETO_OPAQUE, NULL, " ", 1, NULL);
 996         gotit = FALSE;
 997         for (i = 0; i < font_height; i++) {
 998             c = GetPixel(und_dc, font_width / 2, i);
 999             if (c != RGB(0, 0, 0))
1000                 gotit = TRUE;
1001         }
1002         SelectObject(und_dc, und_oldbm);
1003         DeleteObject(und_bm);
1004         DeleteDC(und_dc);
1005         if (!gotit) {
1006             und_mode = UND_LINE;
1007             DeleteObject(fonts[FONT_UNDERLINE]);
1008             fonts[FONT_UNDERLINE] = 0;
1009         }
1010     }
1011
1012     if (bold_mode == BOLD_FONT) {
1013         f(FONT_BOLD, cfg.fontcharset, fw_bold, FALSE);
1014     }
1015 #undef f
1016
1017     descent = tm.tmAscent + 1;
1018     if (descent >= font_height)
1019         descent = font_height - 1;
1020
1021     for (i = 0; i < 3; i++) {
1022         if (fonts[i]) {
1023             if (SelectObject(hdc, fonts[i]) && GetTextMetrics(hdc, &tm))
1024                 fontsize[i] = tm.tmAveCharWidth + 256 * tm.tmHeight;
1025             else
1026                 fontsize[i] = -i;
1027         } else
1028             fontsize[i] = -i;
1029     }
1030
1031     ReleaseDC(hwnd, hdc);
1032
1033     if (fontsize[FONT_UNDERLINE] != fontsize[FONT_NORMAL]) {
1034         und_mode = UND_LINE;
1035         DeleteObject(fonts[FONT_UNDERLINE]);
1036         fonts[FONT_UNDERLINE] = 0;
1037     }
1038
1039     if (bold_mode == BOLD_FONT &&
1040         fontsize[FONT_BOLD] != fontsize[FONT_NORMAL]) {
1041         bold_mode = BOLD_SHADOW;
1042         DeleteObject(fonts[FONT_BOLD]);
1043         fonts[FONT_BOLD] = 0;
1044     }
1045     fontflag[0] = fontflag[1] = fontflag[2] = 1;
1046
1047     init_ucs_tables();
1048 }
1049
1050 static void another_font(int fontno)
1051 {
1052     int basefont;
1053     int fw_dontcare, fw_bold;
1054     int c, u, w, x;
1055     char *s;
1056
1057     if (fontno < 0 || fontno >= FONT_MAXNO || fontflag[fontno])
1058         return;
1059
1060     basefont = (fontno & ~(FONT_BOLDUND));
1061     if (basefont != fontno && !fontflag[basefont])
1062         another_font(basefont);
1063
1064     if (cfg.fontisbold) {
1065         fw_dontcare = FW_BOLD;
1066         fw_bold = FW_HEAVY;
1067     } else {
1068         fw_dontcare = FW_DONTCARE;
1069         fw_bold = FW_BOLD;
1070     }
1071
1072     c = cfg.fontcharset;
1073     w = fw_dontcare;
1074     u = FALSE;
1075     s = cfg.font;
1076     x = font_width;
1077
1078     if (fontno & FONT_WIDE)
1079         x *= 2;
1080     if (fontno & FONT_NARROW)
1081         x = (x+1)/2;
1082     if (fontno & FONT_OEM)
1083         c = OEM_CHARSET;
1084     if (fontno & FONT_BOLD)
1085         w = fw_bold;
1086     if (fontno & FONT_UNDERLINE)
1087         u = TRUE;
1088
1089     fonts[fontno] =
1090         CreateFont(font_height * (1 + !!(fontno & FONT_HIGH)), x, 0, 0, w,
1091                    FALSE, u, FALSE, c, OUT_DEFAULT_PRECIS,
1092                    CLIP_DEFAULT_PRECIS, DEFAULT_QUALITY,
1093                    FIXED_PITCH | FF_DONTCARE, s);
1094
1095     fontflag[fontno] = 1;
1096 }
1097
1098 static void deinit_fonts(void)
1099 {
1100     int i;
1101     for (i = 0; i < FONT_MAXNO; i++) {
1102         if (fonts[i])
1103             DeleteObject(fonts[i]);
1104         fonts[i] = 0;
1105         fontflag[i] = 0;
1106     }
1107 }
1108
1109 void request_resize(int w, int h)
1110 {
1111     int width, height;
1112
1113     /* If the window is maximized supress resizing attempts */
1114     if (IsZoomed(hwnd)) {
1115         if (cfg.resize_action != RESIZE_FONT)
1116             return;
1117     }
1118
1119     if (cfg.resize_action == RESIZE_DISABLED) return;
1120     if (h == rows && w == cols) return;
1121
1122     /* Sanity checks ... */
1123     {
1124         static int first_time = 1;
1125         static RECT ss;
1126
1127         switch (first_time) {
1128           case 1:
1129             /* Get the size of the screen */
1130             if (GetClientRect(GetDesktopWindow(), &ss))
1131                 /* first_time = 0 */ ;
1132             else {
1133                 first_time = 2;
1134                 break;
1135             }
1136           case 0:
1137             /* Make sure the values are sane */
1138             width = (ss.right - ss.left - extra_width) / 4;
1139             height = (ss.bottom - ss.top - extra_height) / 6;
1140
1141             if (w > width || h > height)
1142                 return;
1143             if (w < 15)
1144                 w = 15;
1145             if (h < 1)
1146                 h = 1;
1147         }
1148     }
1149
1150     term_size(h, w, cfg.savelines);
1151
1152     if (cfg.resize_action != RESIZE_FONT) {
1153         width = extra_width + font_width * w;
1154         height = extra_height + font_height * h;
1155
1156         SetWindowPos(hwnd, NULL, 0, 0, width, height,
1157             SWP_NOACTIVATE | SWP_NOCOPYBITS |
1158             SWP_NOMOVE | SWP_NOZORDER);
1159     } else
1160         reset_window(0);
1161
1162     InvalidateRect(hwnd, NULL, TRUE);
1163 }
1164
1165 static void reset_window(int reinit) {
1166     /*
1167      * This function decides how to resize or redraw when the
1168      * user changes something.
1169      *
1170      * This function doesn't like to change the terminal size but if the
1171      * font size is locked that may be it's only soluion.
1172      */
1173     int win_width, win_height;
1174     RECT cr, wr;
1175
1176 #ifdef RDB_DEBUG_PATCH
1177     debug((27, "reset_window()"));
1178 #endif
1179
1180     /* Current window sizes ... */
1181     GetWindowRect(hwnd, &wr);
1182     GetClientRect(hwnd, &cr);
1183
1184     win_width  = cr.right - cr.left;
1185     win_height = cr.bottom - cr.top;
1186
1187     /* Are we being forced to reload the fonts ? */
1188     if (reinit>1) {
1189 #ifdef RDB_DEBUG_PATCH
1190         debug((27, "reset_window() -- Forced deinit"));
1191 #endif
1192         deinit_fonts();
1193         init_fonts(0,0);
1194     }
1195
1196     /* Oh, looks like we're minimised */
1197     if (win_width == 0 || win_height == 0)
1198         return;
1199
1200     /* Is the window out of position ? */
1201     if ( !reinit &&
1202             (offset_width != (win_width-font_width*cols)/2 ||
1203              offset_height != (win_height-font_height*rows)/2) ){
1204         offset_width = (win_width-font_width*cols)/2;
1205         offset_height = (win_height-font_height*rows)/2;
1206         InvalidateRect(hwnd, NULL, TRUE);
1207 #ifdef RDB_DEBUG_PATCH
1208         debug((27, "reset_window() -> Reposition terminal"));
1209 #endif
1210     }
1211
1212     if (IsZoomed(hwnd)) {
1213         /* We're fullscreen, this means we must not change the size of
1214          * the window so it's the font size or the terminal itself.
1215          */
1216
1217         extra_width = wr.right - wr.left - cr.right + cr.left;
1218         extra_height = wr.bottom - wr.top - cr.bottom + cr.top;
1219
1220         if (cfg.resize_action == RESIZE_FONT) {
1221             if (  font_width != win_width/cols ||
1222                   font_height != win_height/rows) {
1223                 deinit_fonts();
1224                 init_fonts(win_width/cols, win_height/rows);
1225                 offset_width = (win_width-font_width*cols)/2;
1226                 offset_height = (win_height-font_height*rows)/2;
1227                 InvalidateRect(hwnd, NULL, TRUE);
1228 #ifdef RDB_DEBUG_PATCH
1229                 debug((25, "reset_window() -> Z font resize to (%d, %d)",
1230                         font_width, font_height));
1231 #endif
1232             }
1233         } else {
1234             if (  font_width != win_width/cols ||
1235                   font_height != win_height/rows) {
1236                 /* Our only choice at this point is to change the
1237                  * size of the terminal; Oh well.
1238                  */
1239                 term_size( win_height/font_height, win_width/font_width,
1240                            cfg.savelines);
1241                 offset_width = (win_width-font_width*cols)/2;
1242                 offset_height = (win_height-font_height*rows)/2;
1243                 InvalidateRect(hwnd, NULL, TRUE);
1244 #ifdef RDB_DEBUG_PATCH
1245                 debug((27, "reset_window() -> Zoomed term_size"));
1246 #endif
1247             }
1248         }
1249         return;
1250     }
1251
1252     /* Hmm, a force re-init means we should ignore the current window
1253      * so we resize to the default font size.
1254      */
1255     if (reinit>0) {
1256 #ifdef RDB_DEBUG_PATCH
1257         debug((27, "reset_window() -> Forced re-init"));
1258 #endif
1259
1260         offset_width = offset_height = cfg.window_border;
1261         extra_width = wr.right - wr.left - cr.right + cr.left + offset_width*2;
1262         extra_height = wr.bottom - wr.top - cr.bottom + cr.top +offset_height*2;
1263
1264         if (win_width != font_width*cols + offset_width*2 ||
1265             win_height != font_height*rows + offset_height*2) {
1266
1267             /* If this is too large windows will resize it to the maximum
1268              * allowed window size, we will then be back in here and resize
1269              * the font or terminal to fit.
1270              */
1271             SetWindowPos(hwnd, NULL, 0, 0,
1272                          font_width*cols + extra_width,
1273                          font_height*rows + extra_height,
1274                          SWP_NOMOVE | SWP_NOZORDER);
1275         }
1276         return;
1277     }
1278
1279     /* Okay the user doesn't want us to change the font so we try the
1280      * window. But that may be too big for the screen which forces us
1281      * to change the terminal.
1282      */
1283     if ((cfg.resize_action != RESIZE_FONT  && reinit==0) || reinit>0) {
1284         offset_width = offset_height = cfg.window_border;
1285         extra_width = wr.right - wr.left - cr.right + cr.left + offset_width*2;
1286         extra_height = wr.bottom - wr.top - cr.bottom + cr.top +offset_height*2;
1287
1288         if (win_width != font_width*cols + offset_width*2 ||
1289             win_height != font_height*rows + offset_height*2) {
1290
1291             static RECT ss;
1292             int width, height;
1293
1294             GetClientRect(GetDesktopWindow(), &ss);
1295             width = (ss.right - ss.left - extra_width) / font_width;
1296             height = (ss.bottom - ss.top - extra_height) / font_height;
1297
1298             /* Grrr too big */
1299             if ( rows > height || cols > width ) {
1300                 if ( height > rows ) height = rows;
1301                 if ( width > cols )  width = cols;
1302                 term_size(height, width, cfg.savelines);
1303 #ifdef RDB_DEBUG_PATCH
1304                 debug((27, "reset_window() -> term resize to (%d,%d)",
1305                            height, width));
1306 #endif
1307             }
1308
1309             SetWindowPos(hwnd, NULL, 0, 0,
1310                          font_width*cols + extra_width,
1311                          font_height*rows + extra_height,
1312                          SWP_NOMOVE | SWP_NOZORDER);
1313
1314             InvalidateRect(hwnd, NULL, TRUE);
1315 #ifdef RDB_DEBUG_PATCH
1316             debug((27, "reset_window() -> window resize to (%d,%d)",
1317                         font_width*cols + extra_width,
1318                         font_height*rows + extra_height));
1319 #endif
1320         }
1321         return;
1322     }
1323
1324     /* We're allowed to or must change the font but do we want to ?  */
1325
1326     if (font_width != (win_width-cfg.window_border*2)/cols ||
1327         font_height != (win_height-cfg.window_border*2)/rows) {
1328
1329         deinit_fonts();
1330         init_fonts((win_width-cfg.window_border*2)/cols,
1331                    (win_height-cfg.window_border*2)/rows);
1332         offset_width = (win_width-font_width*cols)/2;
1333         offset_height = (win_height-font_height*rows)/2;
1334
1335         extra_width = wr.right - wr.left - cr.right + cr.left +offset_width*2;
1336         extra_height = wr.bottom - wr.top - cr.bottom + cr.top+offset_height*2;
1337
1338         InvalidateRect(hwnd, NULL, TRUE);
1339 #ifdef RDB_DEBUG_PATCH
1340         debug((25, "reset_window() -> font resize to (%d,%d)",
1341                    font_width, font_height));
1342 #endif
1343     }
1344 }
1345
1346 static void click(Mouse_Button b, int x, int y, int shift, int ctrl, int alt)
1347 {
1348     int thistime = GetMessageTime();
1349
1350     if (send_raw_mouse && !(cfg.mouse_override && shift)) {
1351         lastbtn = MBT_NOTHING;
1352         term_mouse(b, MA_CLICK, x, y, shift, ctrl, alt);
1353         return;
1354     }
1355
1356     if (lastbtn == b && thistime - lasttime < dbltime) {
1357         lastact = (lastact == MA_CLICK ? MA_2CLK :
1358                    lastact == MA_2CLK ? MA_3CLK :
1359                    lastact == MA_3CLK ? MA_CLICK : MA_NOTHING);
1360     } else {
1361         lastbtn = b;
1362         lastact = MA_CLICK;
1363     }
1364     if (lastact != MA_NOTHING)
1365         term_mouse(b, lastact, x, y, shift, ctrl, alt);
1366     lasttime = thistime;
1367 }
1368
1369 /*
1370  * Translate a raw mouse button designation (LEFT, MIDDLE, RIGHT)
1371  * into a cooked one (SELECT, EXTEND, PASTE).
1372  */
1373 Mouse_Button translate_button(Mouse_Button button)
1374 {
1375     if (button == MBT_LEFT)
1376         return MBT_SELECT;
1377     if (button == MBT_MIDDLE)
1378         return cfg.mouse_is_xterm ? MBT_PASTE : MBT_EXTEND;
1379     if (button == MBT_RIGHT)
1380         return cfg.mouse_is_xterm ? MBT_EXTEND : MBT_PASTE;
1381     return 0;                          /* shouldn't happen */
1382 }
1383
1384 static void show_mouseptr(int show)
1385 {
1386     static int cursor_visible = 1;
1387     if (!cfg.hide_mouseptr)            /* override if this feature disabled */
1388         show = 1;
1389     if (cursor_visible && !show)
1390         ShowCursor(FALSE);
1391     else if (!cursor_visible && show)
1392         ShowCursor(TRUE);
1393     cursor_visible = show;
1394 }
1395
1396 static int is_alt_pressed(void)
1397 {
1398     BYTE keystate[256];
1399     int r = GetKeyboardState(keystate);
1400     if (!r)
1401         return FALSE;
1402     if (keystate[VK_MENU] & 0x80)
1403         return TRUE;
1404     if (keystate[VK_RMENU] & 0x80)
1405         return TRUE;
1406     return FALSE;
1407 }
1408
1409 static LRESULT CALLBACK WndProc(HWND hwnd, UINT message,
1410                                 WPARAM wParam, LPARAM lParam)
1411 {
1412     HDC hdc;
1413     static int ignore_clip = FALSE;
1414     static int resizing = FALSE;
1415     static int need_backend_resize = FALSE;
1416
1417     switch (message) {
1418       case WM_TIMER:
1419         if (pending_netevent)
1420             enact_pending_netevent();
1421         term_out();
1422         noise_regular();
1423         HideCaret(hwnd);
1424         term_update();
1425         ShowCaret(hwnd);
1426         if (cfg.ping_interval > 0) {
1427             time_t now;
1428             time(&now);
1429             if (now - last_movement > cfg.ping_interval) {
1430                 back->special(TS_PING);
1431                 last_movement = now;
1432             }
1433         }
1434         net_pending_errors();
1435         return 0;
1436       case WM_CREATE:
1437         break;
1438       case WM_CLOSE:
1439         show_mouseptr(1);
1440         if (!cfg.warn_on_close || session_closed ||
1441             MessageBox(hwnd,
1442                        "Are you sure you want to close this session?",
1443                        "PuTTY Exit Confirmation",
1444                        MB_ICONWARNING | MB_OKCANCEL) == IDOK)
1445             DestroyWindow(hwnd);
1446         return 0;
1447       case WM_DESTROY:
1448         show_mouseptr(1);
1449         PostQuitMessage(0);
1450         return 0;
1451       case WM_SYSCOMMAND:
1452         switch (wParam & ~0xF) {       /* low 4 bits reserved to Windows */
1453           case IDM_SHOWLOG:
1454             showeventlog(hwnd);
1455             break;
1456           case IDM_NEWSESS:
1457           case IDM_DUPSESS:
1458           case IDM_SAVEDSESS:
1459             {
1460                 char b[2048];
1461                 char c[30], *cl;
1462                 int freecl = FALSE;
1463                 STARTUPINFO si;
1464                 PROCESS_INFORMATION pi;
1465                 HANDLE filemap = NULL;
1466
1467                 if (wParam == IDM_DUPSESS) {
1468                     /*
1469                      * Allocate a file-mapping memory chunk for the
1470                      * config structure.
1471                      */
1472                     SECURITY_ATTRIBUTES sa;
1473                     Config *p;
1474
1475                     sa.nLength = sizeof(sa);
1476                     sa.lpSecurityDescriptor = NULL;
1477                     sa.bInheritHandle = TRUE;
1478                     filemap = CreateFileMapping((HANDLE) 0xFFFFFFFF,
1479                                                 &sa,
1480                                                 PAGE_READWRITE,
1481                                                 0, sizeof(Config), NULL);
1482                     if (filemap) {
1483                         p = (Config *) MapViewOfFile(filemap,
1484                                                      FILE_MAP_WRITE,
1485                                                      0, 0, sizeof(Config));
1486                         if (p) {
1487                             *p = cfg;  /* structure copy */
1488                             UnmapViewOfFile(p);
1489                         }
1490                     }
1491                     sprintf(c, "putty &%p", filemap);
1492                     cl = c;
1493                 } else if (wParam == IDM_SAVEDSESS) {
1494                     char *session =
1495                         sessions[(lParam - IDM_SAVED_MIN) / 16];
1496                     cl = smalloc(16 + strlen(session)); /* 8, but play safe */
1497                     if (!cl)
1498                         cl = NULL;     /* not a very important failure mode */
1499                     else {
1500                         sprintf(cl, "putty @%s", session);
1501                         freecl = TRUE;
1502                     }
1503                 } else
1504                     cl = NULL;
1505
1506                 GetModuleFileName(NULL, b, sizeof(b) - 1);
1507                 si.cb = sizeof(si);
1508                 si.lpReserved = NULL;
1509                 si.lpDesktop = NULL;
1510                 si.lpTitle = NULL;
1511                 si.dwFlags = 0;
1512                 si.cbReserved2 = 0;
1513                 si.lpReserved2 = NULL;
1514                 CreateProcess(b, cl, NULL, NULL, TRUE,
1515                               NORMAL_PRIORITY_CLASS, NULL, NULL, &si, &pi);
1516
1517                 if (filemap)
1518                     CloseHandle(filemap);
1519                 if (freecl)
1520                     sfree(cl);
1521             }
1522             break;
1523           case IDM_RECONF:
1524             {
1525                 Config prev_cfg;
1526                 int init_lvl = 1;
1527
1528                 GetWindowText(hwnd, cfg.wintitle, sizeof(cfg.wintitle));
1529                 prev_cfg = cfg;
1530
1531                 if (!do_reconfig(hwnd))
1532                     break;
1533
1534                 /* If user forcibly disables full-screen, gracefully unzoom */
1535                 if (full_screen && !cfg.fullscreenonaltenter) {
1536                     flip_full_screen();
1537                 }
1538
1539                 if (strcmp(prev_cfg.logfilename, cfg.logfilename) ||
1540                     prev_cfg.logtype != cfg.logtype) {
1541                     logfclose();       /* reset logging */
1542                     logfopen();
1543                 }
1544
1545                 sfree(logpal);
1546                 /*
1547                  * Flush the line discipline's edit buffer in the
1548                  * case where local editing has just been disabled.
1549                  */
1550                 ldisc_send(NULL, 0, 0);
1551                 if (pal)
1552                     DeleteObject(pal);
1553                 logpal = NULL;
1554                 pal = NULL;
1555                 cfgtopalette();
1556                 init_palette();
1557
1558                 /* Screen size changed ? */
1559                 if (cfg.height != prev_cfg.height ||
1560                     cfg.width != prev_cfg.width ||
1561                     cfg.savelines != prev_cfg.savelines ||
1562                     cfg.resize_action != RESIZE_TERM)
1563                     term_size(cfg.height, cfg.width, cfg.savelines);
1564
1565                 /* Enable or disable the scroll bar, etc */
1566                 {
1567                     LONG nflg, flag = GetWindowLong(hwnd, GWL_STYLE);
1568                     LONG nexflag, exflag =
1569                         GetWindowLong(hwnd, GWL_EXSTYLE);
1570
1571                     nexflag = exflag;
1572                     if (cfg.alwaysontop != prev_cfg.alwaysontop) {
1573                         if (cfg.alwaysontop) {
1574                             nexflag |= WS_EX_TOPMOST;
1575                             SetWindowPos(hwnd, HWND_TOPMOST, 0, 0, 0, 0,
1576                                          SWP_NOMOVE | SWP_NOSIZE);
1577                         } else {
1578                             nexflag &= ~(WS_EX_TOPMOST);
1579                             SetWindowPos(hwnd, HWND_NOTOPMOST, 0, 0, 0, 0,
1580                                          SWP_NOMOVE | SWP_NOSIZE);
1581                         }
1582                     }
1583                     if (cfg.sunken_edge)
1584                         nexflag |= WS_EX_CLIENTEDGE;
1585                     else
1586                         nexflag &= ~(WS_EX_CLIENTEDGE);
1587
1588                     nflg = flag;
1589                     if (cfg.scrollbar)
1590                         nflg |= WS_VSCROLL;
1591                     else
1592                         nflg &= ~WS_VSCROLL;
1593                     if (cfg.resize_action == RESIZE_DISABLED)
1594                         nflg &= ~(WS_THICKFRAME | WS_MAXIMIZEBOX);
1595                     else
1596                         nflg |= (WS_THICKFRAME | WS_MAXIMIZEBOX);
1597
1598                     if (nflg != flag || nexflag != exflag) {
1599                         if (nflg != flag)
1600                             SetWindowLong(hwnd, GWL_STYLE, nflg);
1601                         if (nexflag != exflag)
1602                             SetWindowLong(hwnd, GWL_EXSTYLE, nexflag);
1603
1604                         SetWindowPos(hwnd, NULL, 0, 0, 0, 0,
1605                                      SWP_NOACTIVATE | SWP_NOCOPYBITS |
1606                                      SWP_NOMOVE | SWP_NOSIZE | SWP_NOZORDER |
1607                                      SWP_FRAMECHANGED);
1608
1609                         init_lvl = 2;
1610                     }
1611                 }
1612
1613                 /* Oops */
1614                 if (cfg.resize_action == RESIZE_DISABLED && IsZoomed(hwnd)) {
1615                     force_normal(hwnd);
1616                     init_lvl = 2;
1617                 }
1618
1619                 set_title(cfg.wintitle);
1620                 if (IsIconic(hwnd)) {
1621                     SetWindowText(hwnd,
1622                                   cfg.win_name_always ? window_name :
1623                                   icon_name);
1624                 }
1625
1626                 if (strcmp(cfg.font, prev_cfg.font) != 0 ||
1627                     strcmp(cfg.line_codepage, prev_cfg.line_codepage) != 0 ||
1628                     cfg.fontisbold != prev_cfg.fontisbold ||
1629                     cfg.fontheight != prev_cfg.fontheight ||
1630                     cfg.fontcharset != prev_cfg.fontcharset ||
1631                     cfg.vtmode != prev_cfg.vtmode ||
1632                     cfg.bold_colour != prev_cfg.bold_colour ||
1633                     (cfg.resize_action != RESIZE_FONT &&
1634                      prev_cfg.resize_action == RESIZE_FONT))
1635                     init_lvl = 2;
1636
1637                 InvalidateRect(hwnd, NULL, TRUE);
1638                 reset_window(init_lvl);
1639                 net_pending_errors();
1640             }
1641             break;
1642           case IDM_COPYALL:
1643             term_copyall();
1644             break;
1645           case IDM_CLRSB:
1646             term_clrsb();
1647             break;
1648           case IDM_RESET:
1649             term_pwron();
1650             break;
1651           case IDM_TEL_AYT:
1652             back->special(TS_AYT);
1653             net_pending_errors();
1654             break;
1655           case IDM_TEL_BRK:
1656             back->special(TS_BRK);
1657             net_pending_errors();
1658             break;
1659           case IDM_TEL_SYNCH:
1660             back->special(TS_SYNCH);
1661             net_pending_errors();
1662             break;
1663           case IDM_TEL_EC:
1664             back->special(TS_EC);
1665             net_pending_errors();
1666             break;
1667           case IDM_TEL_EL:
1668             back->special(TS_EL);
1669             net_pending_errors();
1670             break;
1671           case IDM_TEL_GA:
1672             back->special(TS_GA);
1673             net_pending_errors();
1674             break;
1675           case IDM_TEL_NOP:
1676             back->special(TS_NOP);
1677             net_pending_errors();
1678             break;
1679           case IDM_TEL_ABORT:
1680             back->special(TS_ABORT);
1681             net_pending_errors();
1682             break;
1683           case IDM_TEL_AO:
1684             back->special(TS_AO);
1685             net_pending_errors();
1686             break;
1687           case IDM_TEL_IP:
1688             back->special(TS_IP);
1689             net_pending_errors();
1690             break;
1691           case IDM_TEL_SUSP:
1692             back->special(TS_SUSP);
1693             net_pending_errors();
1694             break;
1695           case IDM_TEL_EOR:
1696             back->special(TS_EOR);
1697             net_pending_errors();
1698             break;
1699           case IDM_TEL_EOF:
1700             back->special(TS_EOF);
1701             net_pending_errors();
1702             break;
1703           case IDM_ABOUT:
1704             showabout(hwnd);
1705             break;
1706           case SC_MOUSEMENU:
1707             /*
1708              * We get this if the System menu has been activated
1709              * using the mouse.
1710              */
1711             show_mouseptr(1);
1712             break;
1713           case SC_KEYMENU:
1714             /*
1715              * We get this if the System menu has been activated
1716              * using the keyboard. This might happen from within
1717              * TranslateKey, in which case it really wants to be
1718              * followed by a `space' character to actually _bring
1719              * the menu up_ rather than just sitting there in
1720              * `ready to appear' state.
1721              */
1722             show_mouseptr(1);          /* make sure pointer is visible */
1723             if( lParam == 0 )
1724                 PostMessage(hwnd, WM_CHAR, ' ', 0);
1725             break;
1726           case IDM_FULLSCREEN:
1727                 flip_full_screen();
1728                 break;
1729           default:
1730             if (wParam >= IDM_SAVED_MIN && wParam <= IDM_SAVED_MAX) {
1731                 SendMessage(hwnd, WM_SYSCOMMAND, IDM_SAVEDSESS, wParam);
1732             }
1733         }
1734         break;
1735
1736 #define X_POS(l) ((int)(short)LOWORD(l))
1737 #define Y_POS(l) ((int)(short)HIWORD(l))
1738
1739 #define TO_CHR_X(x) ((((x)<0 ? (x)-font_width+1 : (x))-offset_width) / font_width)
1740 #define TO_CHR_Y(y) ((((y)<0 ? (y)-font_height+1: (y))-offset_height) / font_height)
1741 #define WHEEL_DELTA 120
1742       case WM_MOUSEWHEEL:
1743         {
1744             wheel_accumulator += (short) HIWORD(wParam);
1745             wParam = LOWORD(wParam);
1746
1747             /* process events when the threshold is reached */
1748             while (abs(wheel_accumulator) >= WHEEL_DELTA) {
1749                 int b;
1750
1751                 /* reduce amount for next time */
1752                 if (wheel_accumulator > 0) {
1753                     b = MBT_WHEEL_UP;
1754                     wheel_accumulator -= WHEEL_DELTA;
1755                 } else if (wheel_accumulator < 0) {
1756                     b = MBT_WHEEL_DOWN;
1757                     wheel_accumulator += WHEEL_DELTA;
1758                 } else
1759                     break;
1760
1761                 if (send_raw_mouse) {
1762                     /* send a mouse-down followed by a mouse up */
1763
1764                     term_mouse(b,
1765                                MA_CLICK,
1766                                TO_CHR_X(X_POS(lParam)),
1767                                TO_CHR_Y(Y_POS(lParam)), wParam & MK_SHIFT,
1768                                wParam & MK_CONTROL, is_alt_pressed());
1769                     term_mouse(b, MA_RELEASE, TO_CHR_X(X_POS(lParam)),
1770                                TO_CHR_Y(Y_POS(lParam)), wParam & MK_SHIFT,
1771                                wParam & MK_CONTROL, is_alt_pressed());
1772                 } else {
1773                     /* trigger a scroll */
1774                     term_scroll(0,
1775                                 b == MBT_WHEEL_UP ? -rows / 2 : rows / 2);
1776                 }
1777             }
1778             return 0;
1779         }
1780       case WM_LBUTTONDOWN:
1781       case WM_MBUTTONDOWN:
1782       case WM_RBUTTONDOWN:
1783       case WM_LBUTTONUP:
1784       case WM_MBUTTONUP:
1785       case WM_RBUTTONUP:
1786         {
1787             int button, press;
1788
1789             switch (message) {
1790               case WM_LBUTTONDOWN:
1791                 button = MBT_LEFT;
1792                 press = 1;
1793                 break;
1794               case WM_MBUTTONDOWN:
1795                 button = MBT_MIDDLE;
1796                 press = 1;
1797                 break;
1798               case WM_RBUTTONDOWN:
1799                 button = MBT_RIGHT;
1800                 press = 1;
1801                 break;
1802               case WM_LBUTTONUP:
1803                 button = MBT_LEFT;
1804                 press = 0;
1805                 break;
1806               case WM_MBUTTONUP:
1807                 button = MBT_MIDDLE;
1808                 press = 0;
1809                 break;
1810               case WM_RBUTTONUP:
1811                 button = MBT_RIGHT;
1812                 press = 0;
1813                 break;
1814               default:
1815                 button = press = 0;    /* shouldn't happen */
1816             }
1817             show_mouseptr(1);
1818             if (press) {
1819                 click(button,
1820                       TO_CHR_X(X_POS(lParam)), TO_CHR_Y(Y_POS(lParam)),
1821                       wParam & MK_SHIFT, wParam & MK_CONTROL,
1822                       is_alt_pressed());
1823                 SetCapture(hwnd);
1824             } else {
1825                 term_mouse(button, MA_RELEASE,
1826                            TO_CHR_X(X_POS(lParam)),
1827                            TO_CHR_Y(Y_POS(lParam)), wParam & MK_SHIFT,
1828                            wParam & MK_CONTROL, is_alt_pressed());
1829                 ReleaseCapture();
1830             }
1831         }
1832         return 0;
1833       case WM_MOUSEMOVE:
1834         show_mouseptr(1);
1835         /*
1836          * Add the mouse position and message time to the random
1837          * number noise.
1838          */
1839         noise_ultralight(lParam);
1840
1841         if (wParam & (MK_LBUTTON | MK_MBUTTON | MK_RBUTTON)) {
1842             Mouse_Button b;
1843             if (wParam & MK_LBUTTON)
1844                 b = MBT_LEFT;
1845             else if (wParam & MK_MBUTTON)
1846                 b = MBT_MIDDLE;
1847             else
1848                 b = MBT_RIGHT;
1849             term_mouse(b, MA_DRAG, TO_CHR_X(X_POS(lParam)),
1850                        TO_CHR_Y(Y_POS(lParam)), wParam & MK_SHIFT,
1851                        wParam & MK_CONTROL, is_alt_pressed());
1852         }
1853         return 0;
1854       case WM_NCMOUSEMOVE:
1855         show_mouseptr(1);
1856         noise_ultralight(lParam);
1857         return 0;
1858       case WM_IGNORE_CLIP:
1859         ignore_clip = wParam;          /* don't panic on DESTROYCLIPBOARD */
1860         break;
1861       case WM_DESTROYCLIPBOARD:
1862         if (!ignore_clip)
1863             term_deselect();
1864         ignore_clip = FALSE;
1865         return 0;
1866       case WM_PAINT:
1867         {
1868             PAINTSTRUCT p;
1869             HideCaret(hwnd);
1870             hdc = BeginPaint(hwnd, &p);
1871             if (pal) {
1872                 SelectPalette(hdc, pal, TRUE);
1873                 RealizePalette(hdc);
1874             }
1875             term_paint(hdc,
1876                        (p.rcPaint.left-offset_width)/font_width,
1877                        (p.rcPaint.top-offset_height)/font_height,
1878                        (p.rcPaint.right-offset_width-1)/font_width,
1879                        (p.rcPaint.bottom-offset_height-1)/font_height);
1880
1881             if (p.fErase ||
1882                 p.rcPaint.left  < offset_width  ||
1883                 p.rcPaint.top   < offset_height ||
1884                 p.rcPaint.right >= offset_width + font_width*cols ||
1885                 p.rcPaint.bottom>= offset_height + font_height*rows)
1886             {
1887                 HBRUSH fillcolour, oldbrush;
1888                 HPEN   edge, oldpen;
1889                 fillcolour = CreateSolidBrush (
1890                                     colours[(ATTR_DEFBG>>ATTR_BGSHIFT)*2]);
1891                 oldbrush = SelectObject(hdc, fillcolour);
1892                 edge = CreatePen(PS_SOLID, 0,
1893                                     colours[(ATTR_DEFBG>>ATTR_BGSHIFT)*2]);
1894                 oldpen = SelectObject(hdc, edge);
1895
1896                 ExcludeClipRect(hdc,
1897                         offset_width, offset_height,
1898                         offset_width+font_width*cols,
1899                         offset_height+font_height*rows);
1900
1901                 Rectangle(hdc, p.rcPaint.left, p.rcPaint.top,
1902                           p.rcPaint.right, p.rcPaint.bottom);
1903
1904                 // SelectClipRgn(hdc, NULL);
1905
1906                 SelectObject(hdc, oldbrush);
1907                 DeleteObject(fillcolour);
1908                 SelectObject(hdc, oldpen);
1909                 DeleteObject(edge);
1910             }
1911             SelectObject(hdc, GetStockObject(SYSTEM_FONT));
1912             SelectObject(hdc, GetStockObject(WHITE_PEN));
1913             EndPaint(hwnd, &p);
1914             ShowCaret(hwnd);
1915         }
1916         return 0;
1917       case WM_NETEVENT:
1918         /* Notice we can get multiple netevents, FD_READ, FD_WRITE etc
1919          * but the only one that's likely to try to overload us is FD_READ.
1920          * This means buffering just one is fine.
1921          */
1922         if (pending_netevent)
1923             enact_pending_netevent();
1924
1925         pending_netevent = TRUE;
1926         pend_netevent_wParam = wParam;
1927         pend_netevent_lParam = lParam;
1928         if (WSAGETSELECTEVENT(lParam) != FD_READ)
1929             enact_pending_netevent();
1930
1931         time(&last_movement);
1932         return 0;
1933       case WM_SETFOCUS:
1934         has_focus = TRUE;
1935         CreateCaret(hwnd, caretbm, font_width, font_height);
1936         ShowCaret(hwnd);
1937         flash_window(0);               /* stop */
1938         compose_state = 0;
1939         term_out();
1940         term_update();
1941         break;
1942       case WM_KILLFOCUS:
1943         show_mouseptr(1);
1944         has_focus = FALSE;
1945         DestroyCaret();
1946         term_out();
1947         term_update();
1948         break;
1949       case WM_ENTERSIZEMOVE:
1950 #ifdef RDB_DEBUG_PATCH
1951         debug((27, "WM_ENTERSIZEMOVE"));
1952 #endif
1953         EnableSizeTip(1);
1954         resizing = TRUE;
1955         need_backend_resize = FALSE;
1956         break;
1957       case WM_EXITSIZEMOVE:
1958         EnableSizeTip(0);
1959         resizing = FALSE;
1960 #ifdef RDB_DEBUG_PATCH
1961         debug((27, "WM_EXITSIZEMOVE"));
1962 #endif
1963         if (need_backend_resize) {
1964             term_size(cfg.height, cfg.width, cfg.savelines);
1965             InvalidateRect(hwnd, NULL, TRUE);
1966         }
1967         break;
1968       case WM_SIZING:
1969         /*
1970          * This does two jobs:
1971          * 1) Keep the sizetip uptodate
1972          * 2) Make sure the window size is _stepped_ in units of the font size.
1973          */
1974         if (cfg.resize_action == RESIZE_TERM && !alt_pressed) {
1975             int width, height, w, h, ew, eh;
1976             LPRECT r = (LPRECT) lParam;
1977
1978             if ( !need_backend_resize &&
1979                     (cfg.height != rows || cfg.width != cols )) {
1980                 /*
1981                  * Great! It seems the host has been changing the terminal
1982                  * size, well the user is now grabbing so this is probably
1983                  * the least confusing solution in the long run even though
1984                  * it a is suprise. Unfortunatly the only way to prevent
1985                  * this seems to be to let the host change the window size
1986                  * and as that's a user option we're still right back here.
1987                  */
1988                 term_size(cfg.height, cfg.width, cfg.savelines);
1989                 reset_window(2);
1990                 InvalidateRect(hwnd, NULL, TRUE);
1991                 need_backend_resize = TRUE;
1992             }
1993
1994             width = r->right - r->left - extra_width;
1995             height = r->bottom - r->top - extra_height;
1996             w = (width + font_width / 2) / font_width;
1997             if (w < 1)
1998                 w = 1;
1999             h = (height + font_height / 2) / font_height;
2000             if (h < 1)
2001                 h = 1;
2002             UpdateSizeTip(hwnd, w, h);
2003             ew = width - w * font_width;
2004             eh = height - h * font_height;
2005             if (ew != 0) {
2006                 if (wParam == WMSZ_LEFT ||
2007                     wParam == WMSZ_BOTTOMLEFT || wParam == WMSZ_TOPLEFT)
2008                     r->left += ew;
2009                 else
2010                     r->right -= ew;
2011             }
2012             if (eh != 0) {
2013                 if (wParam == WMSZ_TOP ||
2014                     wParam == WMSZ_TOPRIGHT || wParam == WMSZ_TOPLEFT)
2015                     r->top += eh;
2016                 else
2017                     r->bottom -= eh;
2018             }
2019             if (ew || eh)
2020                 return 1;
2021             else
2022                 return 0;
2023         } else {
2024             int width, height, w, h, rv = 0;
2025             int ex_width = extra_width + (cfg.window_border - offset_width) * 2;
2026             int ex_height = extra_height + (cfg.window_border - offset_height) * 2;
2027             LPRECT r = (LPRECT) lParam;
2028
2029             width = r->right - r->left - ex_width;
2030             height = r->bottom - r->top - ex_height;
2031
2032             w = (width + cols/2)/cols;
2033             h = (height + rows/2)/rows;
2034             if ( r->right != r->left + w*cols + ex_width)
2035                 rv = 1;
2036
2037             if (wParam == WMSZ_LEFT ||
2038                 wParam == WMSZ_BOTTOMLEFT || wParam == WMSZ_TOPLEFT)
2039                 r->left = r->right - w*cols - ex_width;
2040             else
2041                 r->right = r->left + w*cols + ex_width;
2042
2043             if (r->bottom != r->top + h*rows + ex_height)
2044                 rv = 1;
2045
2046             if (wParam == WMSZ_TOP ||
2047                 wParam == WMSZ_TOPRIGHT || wParam == WMSZ_TOPLEFT)
2048                 r->top = r->bottom - h*rows - ex_height;
2049             else
2050                 r->bottom = r->top + h*rows + ex_height;
2051
2052             return rv;
2053         }
2054         /* break;  (never reached) */
2055       case WM_SIZE:
2056 #ifdef RDB_DEBUG_PATCH
2057         debug((27, "WM_SIZE %s (%d,%d)",
2058                 (wParam == SIZE_MINIMIZED) ? "SIZE_MINIMIZED":
2059                 (wParam == SIZE_MAXIMIZED) ? "SIZE_MAXIMIZED":
2060                 (wParam == SIZE_RESTORED && resizing) ? "to":
2061                 (wParam == SIZE_RESTORED) ? "SIZE_RESTORED":
2062                 "...",
2063             LOWORD(lParam), HIWORD(lParam)));
2064 #endif
2065         if (wParam == SIZE_MINIMIZED) {
2066             SetWindowText(hwnd,
2067                           cfg.win_name_always ? window_name : icon_name);
2068             break;
2069         }
2070         if (wParam == SIZE_RESTORED || wParam == SIZE_MAXIMIZED)
2071             SetWindowText(hwnd, window_name);
2072
2073         if (cfg.resize_action == RESIZE_DISABLED) {
2074             /* A resize, well it better be a minimize. */
2075             reset_window(-1);
2076         } else {
2077
2078             int width, height, w, h;
2079
2080             width = LOWORD(lParam);
2081             height = HIWORD(lParam);
2082
2083             if (!resizing) {
2084                 if (wParam == SIZE_MAXIMIZED) {
2085                     was_zoomed = 1;
2086                     prev_rows = rows;
2087                     prev_cols = cols;
2088                     if (cfg.resize_action != RESIZE_FONT) {
2089                         w = width / font_width;
2090                         if (w < 1) w = 1;
2091                         h = height / font_height;
2092                         if (h < 1) h = 1;
2093
2094                         term_size(h, w, cfg.savelines);
2095                     }
2096                     reset_window(0);
2097                 } else if (wParam == SIZE_RESTORED && was_zoomed) {
2098                     was_zoomed = 0;
2099                     if (cfg.resize_action != RESIZE_FONT)
2100                         term_size(prev_rows, prev_cols, cfg.savelines);
2101                     reset_window(0);
2102                 }
2103                 /* This is an unexpected resize, these will normally happen
2104                  * if the window is too large. Probably either the user
2105                  * selected a huge font or the screen size has changed.
2106                  *
2107                  * This is also called with minimize.
2108                  */
2109                 else reset_window(-1);
2110             }
2111
2112             /*
2113              * Don't call back->size in mid-resize. (To prevent
2114              * massive numbers of resize events getting sent
2115              * down the connection during an NT opaque drag.)
2116              */
2117             if (resizing) {
2118                 if (cfg.resize_action == RESIZE_TERM && !alt_pressed) {
2119                     need_backend_resize = TRUE;
2120                     w = (width-cfg.window_border*2) / font_width;
2121                     if (w < 1) w = 1;
2122                     h = (height-cfg.window_border*2) / font_height;
2123                     if (h < 1) h = 1;
2124
2125                     cfg.height = h;
2126                     cfg.width = w;
2127                 } else
2128                     reset_window(0);
2129             }
2130         }
2131         return 0;
2132       case WM_VSCROLL:
2133         switch (LOWORD(wParam)) {
2134           case SB_BOTTOM:
2135             term_scroll(-1, 0);
2136             break;
2137           case SB_TOP:
2138             term_scroll(+1, 0);
2139             break;
2140           case SB_LINEDOWN:
2141             term_scroll(0, +1);
2142             break;
2143           case SB_LINEUP:
2144             term_scroll(0, -1);
2145             break;
2146           case SB_PAGEDOWN:
2147             term_scroll(0, +rows / 2);
2148             break;
2149           case SB_PAGEUP:
2150             term_scroll(0, -rows / 2);
2151             break;
2152           case SB_THUMBPOSITION:
2153           case SB_THUMBTRACK:
2154             term_scroll(1, HIWORD(wParam));
2155             break;
2156         }
2157         break;
2158       case WM_PALETTECHANGED:
2159         if ((HWND) wParam != hwnd && pal != NULL) {
2160             HDC hdc = get_ctx();
2161             if (hdc) {
2162                 if (RealizePalette(hdc) > 0)
2163                     UpdateColors(hdc);
2164                 free_ctx(hdc);
2165             }
2166         }
2167         break;
2168       case WM_QUERYNEWPALETTE:
2169         if (pal != NULL) {
2170             HDC hdc = get_ctx();
2171             if (hdc) {
2172                 if (RealizePalette(hdc) > 0)
2173                     UpdateColors(hdc);
2174                 free_ctx(hdc);
2175                 return TRUE;
2176             }
2177         }
2178         return FALSE;
2179       case WM_KEYDOWN:
2180       case WM_SYSKEYDOWN:
2181       case WM_KEYUP:
2182       case WM_SYSKEYUP:
2183         /*
2184          * Add the scan code and keypress timing to the random
2185          * number noise.
2186          */
2187         noise_ultralight(lParam);
2188
2189         /*
2190          * We don't do TranslateMessage since it disassociates the
2191          * resulting CHAR message from the KEYDOWN that sparked it,
2192          * which we occasionally don't want. Instead, we process
2193          * KEYDOWN, and call the Win32 translator functions so that
2194          * we get the translations under _our_ control.
2195          */
2196         {
2197             unsigned char buf[20];
2198             int len;
2199
2200             if (wParam == VK_PROCESSKEY) {
2201                 MSG m;
2202                 m.hwnd = hwnd;
2203                 m.message = WM_KEYDOWN;
2204                 m.wParam = wParam;
2205                 m.lParam = lParam & 0xdfff;
2206                 TranslateMessage(&m);
2207             } else {
2208                 len = TranslateKey(message, wParam, lParam, buf);
2209                 if (len == -1)
2210                     return DefWindowProc(hwnd, message, wParam, lParam);
2211
2212                 if (len != 0) {
2213                     /*
2214                      * Interrupt an ongoing paste. I'm not sure
2215                      * this is sensible, but for the moment it's
2216                      * preferable to having to faff about buffering
2217                      * things.
2218                      */
2219                     term_nopaste();
2220
2221                     /*
2222                      * We need not bother about stdin backlogs
2223                      * here, because in GUI PuTTY we can't do
2224                      * anything about it anyway; there's no means
2225                      * of asking Windows to hold off on KEYDOWN
2226                      * messages. We _have_ to buffer everything
2227                      * we're sent.
2228                      */
2229                     ldisc_send(buf, len, 1);
2230                     show_mouseptr(0);
2231                 }
2232             }
2233         }
2234         net_pending_errors();
2235         return 0;
2236       case WM_INPUTLANGCHANGE:
2237         {
2238             /* wParam == Font number */
2239             /* lParam == Locale */
2240             char lbuf[20];
2241             HKL NewInputLocale = (HKL) lParam;
2242
2243             // lParam == GetKeyboardLayout(0);
2244
2245             GetLocaleInfo(LOWORD(NewInputLocale),
2246                           LOCALE_IDEFAULTANSICODEPAGE, lbuf, sizeof(lbuf));
2247
2248             kbd_codepage = atoi(lbuf);
2249         }
2250         break;
2251       case WM_IME_NOTIFY:
2252         if(wParam == IMN_SETOPENSTATUS) {
2253             HIMC hImc = ImmGetContext(hwnd);
2254             ImmSetCompositionFont(hImc, &lfont);
2255             ImmReleaseContext(hwnd, hImc);
2256             return 0;
2257         }
2258         break;
2259       case WM_IME_COMPOSITION:
2260         {
2261             HIMC hIMC;
2262             int n;
2263             char *buff;
2264
2265             if(osVersion.dwPlatformId == VER_PLATFORM_WIN32_WINDOWS ||
2266                 osVersion.dwPlatformId == VER_PLATFORM_WIN32s) break; /* no Unicode */
2267
2268             if ((lParam & GCS_RESULTSTR) == 0) /* Composition unfinished. */
2269                 break; /* fall back to DefWindowProc */
2270
2271             hIMC = ImmGetContext(hwnd);
2272             n = ImmGetCompositionStringW(hIMC, GCS_RESULTSTR, NULL, 0);
2273
2274             if (n > 0) {
2275                 buff = (char*) smalloc(n);
2276                 ImmGetCompositionStringW(hIMC, GCS_RESULTSTR, buff, n);
2277                 luni_send((unsigned short *)buff, n / 2, 1);
2278                 free(buff);
2279             }
2280             ImmReleaseContext(hwnd, hIMC);
2281             return 1;
2282         }
2283
2284       case WM_IME_CHAR:
2285         if (wParam & 0xFF00) {
2286             unsigned char buf[2];
2287
2288             buf[1] = wParam;
2289             buf[0] = wParam >> 8;
2290             lpage_send(kbd_codepage, buf, 2, 1);
2291         } else {
2292             char c = (unsigned char) wParam;
2293             lpage_send(kbd_codepage, &c, 1, 1);
2294         }
2295         return (0);
2296       case WM_CHAR:
2297       case WM_SYSCHAR:
2298         /*
2299          * Nevertheless, we are prepared to deal with WM_CHAR
2300          * messages, should they crop up. So if someone wants to
2301          * post the things to us as part of a macro manoeuvre,
2302          * we're ready to cope.
2303          */
2304         {
2305             char c = (unsigned char)wParam;
2306             lpage_send(CP_ACP, &c, 1, 1);
2307         }
2308         return 0;
2309       case WM_SETCURSOR:
2310         if (send_raw_mouse && LOWORD(lParam) == HTCLIENT) {
2311             SetCursor(LoadCursor(NULL, IDC_ARROW));
2312             return TRUE;
2313         }
2314     }
2315
2316     return DefWindowProc(hwnd, message, wParam, lParam);
2317 }
2318
2319 /*
2320  * Move the system caret. (We maintain one, even though it's
2321  * invisible, for the benefit of blind people: apparently some
2322  * helper software tracks the system caret, so we should arrange to
2323  * have one.)
2324  */
2325 void sys_cursor(int x, int y)
2326 {
2327     COMPOSITIONFORM cf;
2328     HIMC hIMC;
2329
2330     if (!has_focus) return;
2331
2332     SetCaretPos(x * font_width + offset_width,
2333                 y * font_height + offset_height);
2334
2335     /* IMM calls on Win98 and beyond only */
2336     if(osVersion.dwPlatformId == VER_PLATFORM_WIN32s) return; /* 3.11 */
2337
2338     if(osVersion.dwPlatformId == VER_PLATFORM_WIN32_WINDOWS &&
2339             osVersion.dwMinorVersion == 0) return; /* 95 */
2340
2341     /* we should have the IMM functions */
2342     hIMC = ImmGetContext(hwnd);
2343     cf.dwStyle = CFS_POINT;
2344     cf.ptCurrentPos.x = x * font_width + offset_width;
2345     cf.ptCurrentPos.y = y * font_height + offset_height;
2346     ImmSetCompositionWindow(hIMC, &cf);
2347
2348     ImmReleaseContext(hwnd, hIMC);
2349 }
2350
2351 /*
2352  * Draw a line of text in the window, at given character
2353  * coordinates, in given attributes.
2354  *
2355  * We are allowed to fiddle with the contents of `text'.
2356  */
2357 void do_text(Context ctx, int x, int y, char *text, int len,
2358              unsigned long attr, int lattr)
2359 {
2360     COLORREF fg, bg, t;
2361     int nfg, nbg, nfont;
2362     HDC hdc = ctx;
2363     RECT line_box;
2364     int force_manual_underline = 0;
2365     int fnt_width = font_width * (1 + (lattr != LATTR_NORM));
2366     int char_width = fnt_width;
2367     int text_adjust = 0;
2368     static int *IpDx = 0, IpDxLEN = 0;
2369
2370     if (attr & ATTR_WIDE)
2371         char_width *= 2;
2372
2373     if (len > IpDxLEN || IpDx[0] != char_width) {
2374         int i;
2375         if (len > IpDxLEN) {
2376             sfree(IpDx);
2377             IpDx = smalloc((len + 16) * sizeof(int));
2378             IpDxLEN = (len + 16);
2379         }
2380         for (i = 0; i < IpDxLEN; i++)
2381             IpDx[i] = char_width;
2382     }
2383
2384     /* Only want the left half of double width lines */
2385     if (lattr != LATTR_NORM && x*2 >= cols)
2386         return;
2387
2388     x *= fnt_width;
2389     y *= font_height;
2390     x += offset_width;
2391     y += offset_height;
2392
2393     if ((attr & TATTR_ACTCURS) && (cfg.cursor_type == 0 || big_cursor)) {
2394         attr &= ATTR_CUR_AND | (bold_mode != BOLD_COLOURS ? ATTR_BOLD : 0);
2395         attr ^= ATTR_CUR_XOR;
2396     }
2397
2398     nfont = 0;
2399     if (cfg.vtmode == VT_POORMAN && lattr != LATTR_NORM) {
2400         /* Assume a poorman font is borken in other ways too. */
2401         lattr = LATTR_WIDE;
2402     } else
2403         switch (lattr) {
2404           case LATTR_NORM:
2405             break;
2406           case LATTR_WIDE:
2407             nfont |= FONT_WIDE;
2408             break;
2409           default:
2410             nfont |= FONT_WIDE + FONT_HIGH;
2411             break;
2412         }
2413     if (attr & ATTR_NARROW)
2414         nfont |= FONT_NARROW;
2415
2416     /* Special hack for the VT100 linedraw glyphs. */
2417     if ((attr & CSET_MASK) == 0x2300) {
2418         if (text[0] >= (char) 0xBA && text[0] <= (char) 0xBD) {
2419             switch ((unsigned char) (text[0])) {
2420               case 0xBA:
2421                 text_adjust = -2 * font_height / 5;
2422                 break;
2423               case 0xBB:
2424                 text_adjust = -1 * font_height / 5;
2425                 break;
2426               case 0xBC:
2427                 text_adjust = font_height / 5;
2428                 break;
2429               case 0xBD:
2430                 text_adjust = 2 * font_height / 5;
2431                 break;
2432             }
2433             if (lattr == LATTR_TOP || lattr == LATTR_BOT)
2434                 text_adjust *= 2;
2435             attr &= ~CSET_MASK;
2436             text[0] = (char) (unitab_xterm['q'] & CHAR_MASK);
2437             attr |= (unitab_xterm['q'] & CSET_MASK);
2438             if (attr & ATTR_UNDER) {
2439                 attr &= ~ATTR_UNDER;
2440                 force_manual_underline = 1;
2441             }
2442         }
2443     }
2444
2445     /* Anything left as an original character set is unprintable. */
2446     if (DIRECT_CHAR(attr)) {
2447         attr &= ~CSET_MASK;
2448         attr |= 0xFF00;
2449         memset(text, 0xFD, len);
2450     }
2451
2452     /* OEM CP */
2453     if ((attr & CSET_MASK) == ATTR_OEMCP)
2454         nfont |= FONT_OEM;
2455
2456     nfg = 2 * ((attr & ATTR_FGMASK) >> ATTR_FGSHIFT);
2457     nbg = 2 * ((attr & ATTR_BGMASK) >> ATTR_BGSHIFT);
2458     if (bold_mode == BOLD_FONT && (attr & ATTR_BOLD))
2459         nfont |= FONT_BOLD;
2460     if (und_mode == UND_FONT && (attr & ATTR_UNDER))
2461         nfont |= FONT_UNDERLINE;
2462     another_font(nfont);
2463     if (!fonts[nfont]) {
2464         if (nfont & FONT_UNDERLINE)
2465             force_manual_underline = 1;
2466         /* Don't do the same for manual bold, it could be bad news. */
2467
2468         nfont &= ~(FONT_BOLD | FONT_UNDERLINE);
2469     }
2470     another_font(nfont);
2471     if (!fonts[nfont])
2472         nfont = FONT_NORMAL;
2473     if (attr & ATTR_REVERSE) {
2474         t = nfg;
2475         nfg = nbg;
2476         nbg = t;
2477     }
2478     if (bold_mode == BOLD_COLOURS && (attr & ATTR_BOLD))
2479         nfg++;
2480     if (bold_mode == BOLD_COLOURS && (attr & ATTR_BLINK))
2481         nbg++;
2482     fg = colours[nfg];
2483     bg = colours[nbg];
2484     SelectObject(hdc, fonts[nfont]);
2485     SetTextColor(hdc, fg);
2486     SetBkColor(hdc, bg);
2487     SetBkMode(hdc, OPAQUE);
2488     line_box.left = x;
2489     line_box.top = y;
2490     line_box.right = x + char_width * len;
2491     line_box.bottom = y + font_height;
2492
2493     /* Only want the left half of double width lines */
2494     if (line_box.right > font_width*cols+offset_width)
2495         line_box.right = font_width*cols+offset_width;
2496
2497     /* We're using a private area for direct to font. (512 chars.) */
2498     if (dbcs_screenfont && (attr & CSET_MASK) == ATTR_ACP) {
2499         /* Ho Hum, dbcs fonts are a PITA! */
2500         /* To display on W9x I have to convert to UCS */
2501         static wchar_t *uni_buf = 0;
2502         static int uni_len = 0;
2503         int nlen, mptr;
2504         if (len > uni_len) {
2505             sfree(uni_buf);
2506             uni_buf = smalloc((uni_len = len) * sizeof(wchar_t));
2507         }
2508
2509         for(nlen = mptr = 0; mptr<len; mptr++) {
2510             uni_buf[nlen] = 0xFFFD;
2511             if (IsDBCSLeadByteEx(font_codepage, (BYTE) text[mptr])) {
2512                 IpDx[nlen] += char_width;
2513                 MultiByteToWideChar(font_codepage, MB_USEGLYPHCHARS,
2514                                    text+mptr, 2, uni_buf+nlen, 1);
2515                 mptr++;
2516             }
2517             else
2518             {
2519                 MultiByteToWideChar(font_codepage, MB_USEGLYPHCHARS,
2520                                    text+mptr, 1, uni_buf+nlen, 1);
2521             }
2522             nlen++;
2523         }
2524         if (nlen <= 0)
2525             return;                    /* Eeek! */
2526
2527         ExtTextOutW(hdc, x,
2528                     y - font_height * (lattr == LATTR_BOT) + text_adjust,
2529                     ETO_CLIPPED | ETO_OPAQUE, &line_box, uni_buf, nlen, IpDx);
2530         if (bold_mode == BOLD_SHADOW && (attr & ATTR_BOLD)) {
2531             SetBkMode(hdc, TRANSPARENT);
2532             ExtTextOutW(hdc, x - 1,
2533                         y - font_height * (lattr ==
2534                                            LATTR_BOT) + text_adjust,
2535                         ETO_CLIPPED, &line_box, uni_buf, nlen, IpDx);
2536         }
2537
2538         IpDx[0] = -1;
2539     } else if (DIRECT_FONT(attr)) {
2540         ExtTextOut(hdc, x,
2541                    y - font_height * (lattr == LATTR_BOT) + text_adjust,
2542                    ETO_CLIPPED | ETO_OPAQUE, &line_box, text, len, IpDx);
2543         if (bold_mode == BOLD_SHADOW && (attr & ATTR_BOLD)) {
2544             SetBkMode(hdc, TRANSPARENT);
2545
2546             /* GRR: This draws the character outside it's box and can leave
2547              * 'droppings' even with the clip box! I suppose I could loop it
2548              * one character at a time ... yuk.
2549              *
2550              * Or ... I could do a test print with "W", and use +1 or -1 for this
2551              * shift depending on if the leftmost column is blank...
2552              */
2553             ExtTextOut(hdc, x - 1,
2554                        y - font_height * (lattr ==
2555                                           LATTR_BOT) + text_adjust,
2556                        ETO_CLIPPED, &line_box, text, len, IpDx);
2557         }
2558     } else {
2559         /* And 'normal' unicode characters */
2560         static WCHAR *wbuf = NULL;
2561         static int wlen = 0;
2562         int i;
2563         if (wlen < len) {
2564             sfree(wbuf);
2565             wlen = len;
2566             wbuf = smalloc(wlen * sizeof(WCHAR));
2567         }
2568         for (i = 0; i < len; i++)
2569             wbuf[i] = (WCHAR) ((attr & CSET_MASK) + (text[i] & CHAR_MASK));
2570
2571         ExtTextOutW(hdc, x,
2572                     y - font_height * (lattr == LATTR_BOT) + text_adjust,
2573                     ETO_CLIPPED | ETO_OPAQUE, &line_box, wbuf, len, IpDx);
2574
2575         /* And the shadow bold hack. */
2576         if (bold_mode == BOLD_SHADOW && (attr & ATTR_BOLD)) {
2577             SetBkMode(hdc, TRANSPARENT);
2578             ExtTextOutW(hdc, x - 1,
2579                         y - font_height * (lattr ==
2580                                            LATTR_BOT) + text_adjust,
2581                         ETO_CLIPPED, &line_box, wbuf, len, IpDx);
2582         }
2583     }
2584     if (lattr != LATTR_TOP && (force_manual_underline ||
2585                                (und_mode == UND_LINE
2586                                 && (attr & ATTR_UNDER)))) {
2587         HPEN oldpen;
2588         int dec = descent;
2589         if (lattr == LATTR_BOT)
2590             dec = dec * 2 - font_height;
2591
2592         oldpen = SelectObject(hdc, CreatePen(PS_SOLID, 0, fg));
2593         MoveToEx(hdc, x, y + dec, NULL);
2594         LineTo(hdc, x + len * char_width, y + dec);
2595         oldpen = SelectObject(hdc, oldpen);
2596         DeleteObject(oldpen);
2597     }
2598 }
2599
2600 void do_cursor(Context ctx, int x, int y, char *text, int len,
2601                unsigned long attr, int lattr)
2602 {
2603
2604     int fnt_width;
2605     int char_width;
2606     HDC hdc = ctx;
2607     int ctype = cfg.cursor_type;
2608
2609     if ((attr & TATTR_ACTCURS) && (ctype == 0 || big_cursor)) {
2610         if (((attr & CSET_MASK) | (unsigned char) *text) != UCSWIDE) {
2611             do_text(ctx, x, y, text, len, attr, lattr);
2612             return;
2613         }
2614         ctype = 2;
2615         attr |= TATTR_RIGHTCURS;
2616     }
2617
2618     fnt_width = char_width = font_width * (1 + (lattr != LATTR_NORM));
2619     if (attr & ATTR_WIDE)
2620         char_width *= 2;
2621     x *= fnt_width;
2622     y *= font_height;
2623     x += offset_width;
2624     y += offset_height;
2625
2626     if ((attr & TATTR_PASCURS) && (ctype == 0 || big_cursor)) {
2627         POINT pts[5];
2628         HPEN oldpen;
2629         pts[0].x = pts[1].x = pts[4].x = x;
2630         pts[2].x = pts[3].x = x + char_width - 1;
2631         pts[0].y = pts[3].y = pts[4].y = y;
2632         pts[1].y = pts[2].y = y + font_height - 1;
2633         oldpen = SelectObject(hdc, CreatePen(PS_SOLID, 0, colours[23]));
2634         Polyline(hdc, pts, 5);
2635         oldpen = SelectObject(hdc, oldpen);
2636         DeleteObject(oldpen);
2637     } else if ((attr & (TATTR_ACTCURS | TATTR_PASCURS)) && ctype != 0) {
2638         int startx, starty, dx, dy, length, i;
2639         if (ctype == 1) {
2640             startx = x;
2641             starty = y + descent;
2642             dx = 1;
2643             dy = 0;
2644             length = char_width;
2645         } else {
2646             int xadjust = 0;
2647             if (attr & TATTR_RIGHTCURS)
2648                 xadjust = char_width - 1;
2649             startx = x + xadjust;
2650             starty = y;
2651             dx = 0;
2652             dy = 1;
2653             length = font_height;
2654         }
2655         if (attr & TATTR_ACTCURS) {
2656             HPEN oldpen;
2657             oldpen =
2658                 SelectObject(hdc, CreatePen(PS_SOLID, 0, colours[23]));
2659             MoveToEx(hdc, startx, starty, NULL);
2660             LineTo(hdc, startx + dx * length, starty + dy * length);
2661             oldpen = SelectObject(hdc, oldpen);
2662             DeleteObject(oldpen);
2663         } else {
2664             for (i = 0; i < length; i++) {
2665                 if (i % 2 == 0) {
2666                     SetPixel(hdc, startx, starty, colours[23]);
2667                 }
2668                 startx += dx;
2669                 starty += dy;
2670             }
2671         }
2672     }
2673 }
2674
2675 /* This function gets the actual width of a character in the normal font.
2676  */
2677 int CharWidth(Context ctx, int uc) {
2678     HDC hdc = ctx;
2679     int ibuf = 0;
2680
2681     /* If the font max is the same as the font ave width then this
2682      * function is a no-op.
2683      */
2684     if (!font_dualwidth) return 1;
2685
2686     switch (uc & CSET_MASK) {
2687       case ATTR_ASCII:
2688         uc = unitab_line[uc & 0xFF];
2689         break;
2690       case ATTR_LINEDRW:
2691         uc = unitab_xterm[uc & 0xFF];
2692         break;
2693       case ATTR_SCOACS:
2694         uc = unitab_scoacs[uc & 0xFF];
2695         break;
2696     }
2697     if (DIRECT_FONT(uc)) {
2698         if (dbcs_screenfont) return 1;
2699
2700         /* Speedup, I know of no font where ascii is the wrong width */
2701         if ((uc&CHAR_MASK) >= ' ' && (uc&CHAR_MASK)<= '~')
2702             return 1;
2703
2704         if ( (uc & CSET_MASK) == ATTR_ACP ) {
2705             SelectObject(hdc, fonts[FONT_NORMAL]);
2706         } else if ( (uc & CSET_MASK) == ATTR_OEMCP ) {
2707             another_font(FONT_OEM);
2708             if (!fonts[FONT_OEM]) return 0;
2709
2710             SelectObject(hdc, fonts[FONT_OEM]);
2711         } else
2712             return 0;
2713
2714         if ( GetCharWidth32(hdc, uc&CHAR_MASK, uc&CHAR_MASK, &ibuf) != 1 &&
2715              GetCharWidth(hdc, uc&CHAR_MASK, uc&CHAR_MASK, &ibuf) != 1)
2716             return 0;
2717     } else {
2718         /* Speedup, I know of no font where ascii is the wrong width */
2719         if (uc >= ' ' && uc <= '~') return 1;
2720
2721         SelectObject(hdc, fonts[FONT_NORMAL]);
2722         if ( GetCharWidth32W(hdc, uc, uc, &ibuf) == 1 )
2723             /* Okay that one worked */ ;
2724         else if ( GetCharWidthW(hdc, uc, uc, &ibuf) == 1 )
2725             /* This should work on 9x too, but it's "less accurate" */ ;
2726         else
2727             return 0;
2728     }
2729
2730     ibuf += font_width / 2 -1;
2731     ibuf /= font_width;
2732
2733     return ibuf;
2734 }
2735
2736 /*
2737  * Translate a WM_(SYS)?KEY(UP|DOWN) message into a string of ASCII
2738  * codes. Returns number of bytes used or zero to drop the message
2739  * or -1 to forward the message to windows.
2740  */
2741 static int TranslateKey(UINT message, WPARAM wParam, LPARAM lParam,
2742                         unsigned char *output)
2743 {
2744     BYTE keystate[256];
2745     int scan, left_alt = 0, key_down, shift_state;
2746     int r, i, code;
2747     unsigned char *p = output;
2748     static int alt_sum = 0;
2749
2750     HKL kbd_layout = GetKeyboardLayout(0);
2751
2752     static WORD keys[3];
2753     static int compose_char = 0;
2754     static WPARAM compose_key = 0;
2755
2756     r = GetKeyboardState(keystate);
2757     if (!r)
2758         memset(keystate, 0, sizeof(keystate));
2759     else {
2760 #if 0
2761 #define SHOW_TOASCII_RESULT
2762         {                              /* Tell us all about key events */
2763             static BYTE oldstate[256];
2764             static int first = 1;
2765             static int scan;
2766             int ch;
2767             if (first)
2768                 memcpy(oldstate, keystate, sizeof(oldstate));
2769             first = 0;
2770
2771             if ((HIWORD(lParam) & (KF_UP | KF_REPEAT)) == KF_REPEAT) {
2772                 debug(("+"));
2773             } else if ((HIWORD(lParam) & KF_UP)
2774                        && scan == (HIWORD(lParam) & 0xFF)) {
2775                 debug((". U"));
2776             } else {
2777                 debug((".\n"));
2778                 if (wParam >= VK_F1 && wParam <= VK_F20)
2779                     debug(("K_F%d", wParam + 1 - VK_F1));
2780                 else
2781                     switch (wParam) {
2782                       case VK_SHIFT:
2783                         debug(("SHIFT"));
2784                         break;
2785                       case VK_CONTROL:
2786                         debug(("CTRL"));
2787                         break;
2788                       case VK_MENU:
2789                         debug(("ALT"));
2790                         break;
2791                       default:
2792                         debug(("VK_%02x", wParam));
2793                     }
2794                 if (message == WM_SYSKEYDOWN || message == WM_SYSKEYUP)
2795                     debug(("*"));
2796                 debug((", S%02x", scan = (HIWORD(lParam) & 0xFF)));
2797
2798                 ch = MapVirtualKeyEx(wParam, 2, kbd_layout);
2799                 if (ch >= ' ' && ch <= '~')
2800                     debug((", '%c'", ch));
2801                 else if (ch)
2802                     debug((", $%02x", ch));
2803
2804                 if (keys[0])
2805                     debug((", KB0=%02x", keys[0]));
2806                 if (keys[1])
2807                     debug((", KB1=%02x", keys[1]));
2808                 if (keys[2])
2809                     debug((", KB2=%02x", keys[2]));
2810
2811                 if ((keystate[VK_SHIFT] & 0x80) != 0)
2812                     debug((", S"));
2813                 if ((keystate[VK_CONTROL] & 0x80) != 0)
2814                     debug((", C"));
2815                 if ((HIWORD(lParam) & KF_EXTENDED))
2816                     debug((", E"));
2817                 if ((HIWORD(lParam) & KF_UP))
2818                     debug((", U"));
2819             }
2820
2821             if ((HIWORD(lParam) & (KF_UP | KF_REPEAT)) == KF_REPEAT);
2822             else if ((HIWORD(lParam) & KF_UP))
2823                 oldstate[wParam & 0xFF] ^= 0x80;
2824             else
2825                 oldstate[wParam & 0xFF] ^= 0x81;
2826
2827             for (ch = 0; ch < 256; ch++)
2828                 if (oldstate[ch] != keystate[ch])
2829                     debug((", M%02x=%02x", ch, keystate[ch]));
2830
2831             memcpy(oldstate, keystate, sizeof(oldstate));
2832         }
2833 #endif
2834
2835         if (wParam == VK_MENU && (HIWORD(lParam) & KF_EXTENDED)) {
2836             keystate[VK_RMENU] = keystate[VK_MENU];
2837         }
2838
2839
2840         /* Nastyness with NUMLock - Shift-NUMLock is left alone though */
2841         if ((cfg.funky_type == 3 ||
2842              (cfg.funky_type <= 1 && app_keypad_keys && !cfg.no_applic_k))
2843             && wParam == VK_NUMLOCK && !(keystate[VK_SHIFT] & 0x80)) {
2844
2845             wParam = VK_EXECUTE;
2846
2847             /* UnToggle NUMLock */
2848             if ((HIWORD(lParam) & (KF_UP | KF_REPEAT)) == 0)
2849                 keystate[VK_NUMLOCK] ^= 1;
2850         }
2851
2852         /* And write back the 'adjusted' state */
2853         SetKeyboardState(keystate);
2854     }
2855
2856     /* Disable Auto repeat if required */
2857     if (repeat_off && (HIWORD(lParam) & (KF_UP | KF_REPEAT)) == KF_REPEAT)
2858         return 0;
2859
2860     if ((HIWORD(lParam) & KF_ALTDOWN) && (keystate[VK_RMENU] & 0x80) == 0)
2861         left_alt = 1;
2862
2863     key_down = ((HIWORD(lParam) & KF_UP) == 0);
2864
2865     /* Make sure Ctrl-ALT is not the same as AltGr for ToAscii unless told. */
2866     if (left_alt && (keystate[VK_CONTROL] & 0x80)) {
2867         if (cfg.ctrlaltkeys)
2868             keystate[VK_MENU] = 0;
2869         else {
2870             keystate[VK_RMENU] = 0x80;
2871             left_alt = 0;
2872         }
2873     }
2874
2875     alt_pressed = (left_alt && key_down);
2876
2877     scan = (HIWORD(lParam) & (KF_UP | KF_EXTENDED | 0xFF));
2878     shift_state = ((keystate[VK_SHIFT] & 0x80) != 0)
2879         + ((keystate[VK_CONTROL] & 0x80) != 0) * 2;
2880
2881     /* Note if AltGr was pressed and if it was used as a compose key */
2882     if (!compose_state) {
2883         compose_key = 0x100;
2884         if (cfg.compose_key) {
2885             if (wParam == VK_MENU && (HIWORD(lParam) & KF_EXTENDED))
2886                 compose_key = wParam;
2887         }
2888         if (wParam == VK_APPS)
2889             compose_key = wParam;
2890     }
2891
2892     if (wParam == compose_key) {
2893         if (compose_state == 0
2894             && (HIWORD(lParam) & (KF_UP | KF_REPEAT)) == 0) compose_state =
2895                 1;
2896         else if (compose_state == 1 && (HIWORD(lParam) & KF_UP))
2897             compose_state = 2;
2898         else
2899             compose_state = 0;
2900     } else if (compose_state == 1 && wParam != VK_CONTROL)
2901         compose_state = 0;
2902
2903     /*
2904      * Record that we pressed key so the scroll window can be reset, but
2905      * be careful to avoid Shift-UP/Down
2906      */
2907     if (wParam != VK_SHIFT && wParam != VK_PRIOR && wParam != VK_NEXT &&
2908         wParam != VK_MENU && wParam != VK_CONTROL) {
2909         seen_key_event = 1;
2910     }
2911
2912     if (compose_state > 1 && left_alt)
2913         compose_state = 0;
2914
2915     /* Sanitize the number pad if not using a PC NumPad */
2916     if (left_alt || (app_keypad_keys && !cfg.no_applic_k
2917                      && cfg.funky_type != 2)
2918         || cfg.funky_type == 3 || cfg.nethack_keypad || compose_state) {
2919         if ((HIWORD(lParam) & KF_EXTENDED) == 0) {
2920             int nParam = 0;
2921             switch (wParam) {
2922               case VK_INSERT:
2923                 nParam = VK_NUMPAD0;
2924                 break;
2925               case VK_END:
2926                 nParam = VK_NUMPAD1;
2927                 break;
2928               case VK_DOWN:
2929                 nParam = VK_NUMPAD2;
2930                 break;
2931               case VK_NEXT:
2932                 nParam = VK_NUMPAD3;
2933                 break;
2934               case VK_LEFT:
2935                 nParam = VK_NUMPAD4;
2936                 break;
2937               case VK_CLEAR:
2938                 nParam = VK_NUMPAD5;
2939                 break;
2940               case VK_RIGHT:
2941                 nParam = VK_NUMPAD6;
2942                 break;
2943               case VK_HOME:
2944                 nParam = VK_NUMPAD7;
2945                 break;
2946               case VK_UP:
2947                 nParam = VK_NUMPAD8;
2948                 break;
2949               case VK_PRIOR:
2950                 nParam = VK_NUMPAD9;
2951                 break;
2952               case VK_DELETE:
2953                 nParam = VK_DECIMAL;
2954                 break;
2955             }
2956             if (nParam) {
2957                 if (keystate[VK_NUMLOCK] & 1)
2958                     shift_state |= 1;
2959                 wParam = nParam;
2960             }
2961         }
2962     }
2963
2964     /* If a key is pressed and AltGr is not active */
2965     if (key_down && (keystate[VK_RMENU] & 0x80) == 0 && !compose_state) {
2966         /* Okay, prepare for most alts then ... */
2967         if (left_alt)
2968             *p++ = '\033';
2969
2970         /* Lets see if it's a pattern we know all about ... */
2971         if (wParam == VK_PRIOR && shift_state == 1) {
2972             SendMessage(hwnd, WM_VSCROLL, SB_PAGEUP, 0);
2973             return 0;
2974         }
2975         if (wParam == VK_NEXT && shift_state == 1) {
2976             SendMessage(hwnd, WM_VSCROLL, SB_PAGEDOWN, 0);
2977             return 0;
2978         }
2979         if (wParam == VK_INSERT && shift_state == 1) {
2980             term_do_paste();
2981             return 0;
2982         }
2983         if (left_alt && wParam == VK_F4 && cfg.alt_f4) {
2984             return -1;
2985         }
2986         if (left_alt && wParam == VK_SPACE && cfg.alt_space) {
2987             SendMessage(hwnd, WM_SYSCOMMAND, SC_KEYMENU, 0);
2988             return -1;
2989         }
2990         if (left_alt && wParam == VK_RETURN && cfg.fullscreenonaltenter) {
2991             flip_full_screen();
2992             return -1;
2993         }
2994         /* Control-Numlock for app-keypad mode switch */
2995         if (wParam == VK_PAUSE && shift_state == 2) {
2996             app_keypad_keys ^= 1;
2997             return 0;
2998         }
2999
3000         /* Nethack keypad */
3001         if (cfg.nethack_keypad && !left_alt) {
3002             switch (wParam) {
3003               case VK_NUMPAD1:
3004                 *p++ = shift_state ? 'B' : 'b';
3005                 return p - output;
3006               case VK_NUMPAD2:
3007                 *p++ = shift_state ? 'J' : 'j';
3008                 return p - output;
3009               case VK_NUMPAD3:
3010                 *p++ = shift_state ? 'N' : 'n';
3011                 return p - output;
3012               case VK_NUMPAD4:
3013                 *p++ = shift_state ? 'H' : 'h';
3014                 return p - output;
3015               case VK_NUMPAD5:
3016                 *p++ = shift_state ? '.' : '.';
3017                 return p - output;
3018               case VK_NUMPAD6:
3019                 *p++ = shift_state ? 'L' : 'l';
3020                 return p - output;
3021               case VK_NUMPAD7:
3022                 *p++ = shift_state ? 'Y' : 'y';
3023                 return p - output;
3024               case VK_NUMPAD8:
3025                 *p++ = shift_state ? 'K' : 'k';
3026                 return p - output;
3027               case VK_NUMPAD9:
3028                 *p++ = shift_state ? 'U' : 'u';
3029                 return p - output;
3030             }
3031         }
3032
3033         /* Application Keypad */
3034         if (!left_alt) {
3035             int xkey = 0;
3036
3037             if (cfg.funky_type == 3 ||
3038                 (cfg.funky_type <= 1 &&
3039                  app_keypad_keys && !cfg.no_applic_k)) switch (wParam) {
3040                   case VK_EXECUTE:
3041                     xkey = 'P';
3042                     break;
3043                   case VK_DIVIDE:
3044                     xkey = 'Q';
3045                     break;
3046                   case VK_MULTIPLY:
3047                     xkey = 'R';
3048                     break;
3049                   case VK_SUBTRACT:
3050                     xkey = 'S';
3051                     break;
3052                 }
3053             if (app_keypad_keys && !cfg.no_applic_k)
3054                 switch (wParam) {
3055                   case VK_NUMPAD0:
3056                     xkey = 'p';
3057                     break;
3058                   case VK_NUMPAD1:
3059                     xkey = 'q';
3060                     break;
3061                   case VK_NUMPAD2:
3062                     xkey = 'r';
3063                     break;
3064                   case VK_NUMPAD3:
3065                     xkey = 's';
3066                     break;
3067                   case VK_NUMPAD4:
3068                     xkey = 't';
3069                     break;
3070                   case VK_NUMPAD5:
3071                     xkey = 'u';
3072                     break;
3073                   case VK_NUMPAD6:
3074                     xkey = 'v';
3075                     break;
3076                   case VK_NUMPAD7:
3077                     xkey = 'w';
3078                     break;
3079                   case VK_NUMPAD8:
3080                     xkey = 'x';
3081                     break;
3082                   case VK_NUMPAD9:
3083                     xkey = 'y';
3084                     break;
3085
3086                   case VK_DECIMAL:
3087                     xkey = 'n';
3088                     break;
3089                   case VK_ADD:
3090                     if (cfg.funky_type == 2) {
3091                         if (shift_state)
3092                             xkey = 'l';
3093                         else
3094                             xkey = 'k';
3095                     } else if (shift_state)
3096                         xkey = 'm';
3097                     else
3098                         xkey = 'l';
3099                     break;
3100
3101                   case VK_DIVIDE:
3102                     if (cfg.funky_type == 2)
3103                         xkey = 'o';
3104                     break;
3105                   case VK_MULTIPLY:
3106                     if (cfg.funky_type == 2)
3107                         xkey = 'j';
3108                     break;
3109                   case VK_SUBTRACT:
3110                     if (cfg.funky_type == 2)
3111                         xkey = 'm';
3112                     break;
3113
3114                   case VK_RETURN:
3115                     if (HIWORD(lParam) & KF_EXTENDED)
3116                         xkey = 'M';
3117                     break;
3118                 }
3119             if (xkey) {
3120                 if (vt52_mode) {
3121                     if (xkey >= 'P' && xkey <= 'S')
3122                         p += sprintf((char *) p, "\x1B%c", xkey);
3123                     else
3124                         p += sprintf((char *) p, "\x1B?%c", xkey);
3125                 } else
3126                     p += sprintf((char *) p, "\x1BO%c", xkey);
3127                 return p - output;
3128             }
3129         }
3130
3131         if (wParam == VK_BACK && shift_state == 0) {    /* Backspace */
3132             *p++ = (cfg.bksp_is_delete ? 0x7F : 0x08);
3133             *p++ = 0;
3134             return -2;
3135         }
3136         if (wParam == VK_TAB && shift_state == 1) {     /* Shift tab */
3137             *p++ = 0x1B;
3138             *p++ = '[';
3139             *p++ = 'Z';
3140             return p - output;
3141         }
3142         if (wParam == VK_SPACE && shift_state == 2) {   /* Ctrl-Space */
3143             *p++ = 0;
3144             return p - output;
3145         }
3146         if (wParam == VK_SPACE && shift_state == 3) {   /* Ctrl-Shift-Space */
3147             *p++ = 160;
3148             return p - output;
3149         }
3150         if (wParam == VK_CANCEL && shift_state == 2) {  /* Ctrl-Break */
3151             *p++ = 3;
3152             *p++ = 0;
3153             return -2;
3154         }
3155         if (wParam == VK_PAUSE) {      /* Break/Pause */
3156             *p++ = 26;
3157             *p++ = 0;
3158             return -2;
3159         }
3160         /* Control-2 to Control-8 are special */
3161         if (shift_state == 2 && wParam >= '2' && wParam <= '8') {
3162             *p++ = "\000\033\034\035\036\037\177"[wParam - '2'];
3163             return p - output;
3164         }
3165         if (shift_state == 2 && wParam == 0xBD) {
3166             *p++ = 0x1F;
3167             return p - output;
3168         }
3169         if (shift_state == 2 && wParam == 0xDF) {
3170             *p++ = 0x1C;
3171             return p - output;
3172         }
3173         if (shift_state == 0 && wParam == VK_RETURN && cr_lf_return) {
3174             *p++ = '\r';
3175             *p++ = '\n';
3176             return p - output;
3177         }
3178
3179         /*
3180          * Next, all the keys that do tilde codes. (ESC '[' nn '~',
3181          * for integer decimal nn.)
3182          *
3183          * We also deal with the weird ones here. Linux VCs replace F1
3184          * to F5 by ESC [ [ A to ESC [ [ E. rxvt doesn't do _that_, but
3185          * does replace Home and End (1~ and 4~) by ESC [ H and ESC O w
3186          * respectively.
3187          */
3188         code = 0;
3189         switch (wParam) {
3190           case VK_F1:
3191             code = (keystate[VK_SHIFT] & 0x80 ? 23 : 11);
3192             break;
3193           case VK_F2:
3194             code = (keystate[VK_SHIFT] & 0x80 ? 24 : 12);
3195             break;
3196           case VK_F3:
3197             code = (keystate[VK_SHIFT] & 0x80 ? 25 : 13);
3198             break;
3199           case VK_F4:
3200             code = (keystate[VK_SHIFT] & 0x80 ? 26 : 14);
3201             break;
3202           case VK_F5:
3203             code = (keystate[VK_SHIFT] & 0x80 ? 28 : 15);
3204             break;
3205           case VK_F6:
3206             code = (keystate[VK_SHIFT] & 0x80 ? 29 : 17);
3207             break;
3208           case VK_F7:
3209             code = (keystate[VK_SHIFT] & 0x80 ? 31 : 18);
3210             break;
3211           case VK_F8:
3212             code = (keystate[VK_SHIFT] & 0x80 ? 32 : 19);
3213             break;
3214           case VK_F9:
3215             code = (keystate[VK_SHIFT] & 0x80 ? 33 : 20);
3216             break;
3217           case VK_F10:
3218             code = (keystate[VK_SHIFT] & 0x80 ? 34 : 21);
3219             break;
3220           case VK_F11:
3221             code = 23;
3222             break;
3223           case VK_F12:
3224             code = 24;
3225             break;
3226           case VK_F13:
3227             code = 25;
3228             break;
3229           case VK_F14:
3230             code = 26;
3231             break;
3232           case VK_F15:
3233             code = 28;
3234             break;
3235           case VK_F16:
3236             code = 29;
3237             break;
3238           case VK_F17:
3239             code = 31;
3240             break;
3241           case VK_F18:
3242             code = 32;
3243             break;
3244           case VK_F19:
3245             code = 33;
3246             break;
3247           case VK_F20:
3248             code = 34;
3249             break;
3250         }
3251         if ((shift_state&2) == 0) switch (wParam) {
3252           case VK_HOME:
3253             code = 1;
3254             break;
3255           case VK_INSERT:
3256             code = 2;
3257             break;
3258           case VK_DELETE:
3259             code = 3;
3260             break;
3261           case VK_END:
3262             code = 4;
3263             break;
3264           case VK_PRIOR:
3265             code = 5;
3266             break;
3267           case VK_NEXT:
3268             code = 6;
3269             break;
3270         }
3271         /* Reorder edit keys to physical order */
3272         if (cfg.funky_type == 3 && code <= 6)
3273             code = "\0\2\1\4\5\3\6"[code];
3274
3275         if (vt52_mode && code > 0 && code <= 6) {
3276             p += sprintf((char *) p, "\x1B%c", " HLMEIG"[code]);
3277             return p - output;
3278         }
3279
3280         if (cfg.funky_type == 5 &&     /* SCO function keys */
3281             code >= 11 && code <= 34) {
3282             char codes[] = "MNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz@[\\]^_`{";
3283             int index = 0;
3284             switch (wParam) {
3285               case VK_F1: index = 0; break;
3286               case VK_F2: index = 1; break;
3287               case VK_F3: index = 2; break;
3288               case VK_F4: index = 3; break;
3289               case VK_F5: index = 4; break;
3290               case VK_F6: index = 5; break;
3291               case VK_F7: index = 6; break;
3292               case VK_F8: index = 7; break;
3293               case VK_F9: index = 8; break;
3294               case VK_F10: index = 9; break;
3295               case VK_F11: index = 10; break;
3296               case VK_F12: index = 11; break;
3297             }
3298             if (keystate[VK_SHIFT] & 0x80) index += 12;
3299             if (keystate[VK_CONTROL] & 0x80) index += 24;
3300             p += sprintf((char *) p, "\x1B[%c", codes[index]);
3301             return p - output;
3302         }
3303         if (cfg.funky_type == 5 &&     /* SCO small keypad */
3304             code >= 1 && code <= 6) {
3305             char codes[] = "HL.FIG";
3306             if (code == 3) {
3307                 *p++ = '\x7F';
3308             } else {
3309                 p += sprintf((char *) p, "\x1B[%c", codes[code-1]);
3310             }
3311             return p - output;
3312         }
3313         if ((vt52_mode || cfg.funky_type == 4) && code >= 11 && code <= 24) {
3314             int offt = 0;
3315             if (code > 15)
3316                 offt++;
3317             if (code > 21)
3318                 offt++;
3319             if (vt52_mode)
3320                 p += sprintf((char *) p, "\x1B%c", code + 'P' - 11 - offt);
3321             else
3322                 p +=
3323                     sprintf((char *) p, "\x1BO%c", code + 'P' - 11 - offt);
3324             return p - output;
3325         }
3326         if (cfg.funky_type == 1 && code >= 11 && code <= 15) {
3327             p += sprintf((char *) p, "\x1B[[%c", code + 'A' - 11);
3328             return p - output;
3329         }
3330         if (cfg.funky_type == 2 && code >= 11 && code <= 14) {
3331             if (vt52_mode)
3332                 p += sprintf((char *) p, "\x1B%c", code + 'P' - 11);
3333             else
3334                 p += sprintf((char *) p, "\x1BO%c", code + 'P' - 11);
3335             return p - output;
3336         }
3337         if (cfg.rxvt_homeend && (code == 1 || code == 4)) {
3338             p += sprintf((char *) p, code == 1 ? "\x1B[H" : "\x1BOw");
3339             return p - output;
3340         }
3341         if (code) {
3342             p += sprintf((char *) p, "\x1B[%d~", code);
3343             return p - output;
3344         }
3345
3346         /*
3347          * Now the remaining keys (arrows and Keypad 5. Keypad 5 for
3348          * some reason seems to send VK_CLEAR to Windows...).
3349          */
3350         {
3351             char xkey = 0;
3352             switch (wParam) {
3353               case VK_UP:
3354                 xkey = 'A';
3355                 break;
3356               case VK_DOWN:
3357                 xkey = 'B';
3358                 break;
3359               case VK_RIGHT:
3360                 xkey = 'C';
3361                 break;
3362               case VK_LEFT:
3363                 xkey = 'D';
3364                 break;
3365               case VK_CLEAR:
3366                 xkey = 'G';
3367                 break;
3368             }
3369             if (xkey) {
3370                 if (vt52_mode)
3371                     p += sprintf((char *) p, "\x1B%c", xkey);
3372                 else {
3373                     int app_flg = (app_cursor_keys && !cfg.no_applic_c);
3374                     /* VT100 & VT102 manuals both state the app cursor keys
3375                      * only work if the app keypad is on.
3376                      */
3377                     if (!app_keypad_keys)
3378                         app_flg = 0;
3379                     /* Useful mapping of Ctrl-arrows */
3380                     if (shift_state == 2)
3381                         app_flg = !app_flg;
3382
3383                     if (app_flg)
3384                         p += sprintf((char *) p, "\x1BO%c", xkey);
3385                     else
3386                         p += sprintf((char *) p, "\x1B[%c", xkey);
3387                 }
3388                 return p - output;
3389             }
3390         }
3391
3392         /*
3393          * Finally, deal with Return ourselves. (Win95 seems to
3394          * foul it up when Alt is pressed, for some reason.)
3395          */
3396         if (wParam == VK_RETURN) {     /* Return */
3397             *p++ = 0x0D;
3398             *p++ = 0;
3399             return -2;
3400         }
3401
3402         if (left_alt && wParam >= VK_NUMPAD0 && wParam <= VK_NUMPAD9)
3403             alt_sum = alt_sum * 10 + wParam - VK_NUMPAD0;
3404         else
3405             alt_sum = 0;
3406     }
3407
3408     /* Okay we've done everything interesting; let windows deal with
3409      * the boring stuff */
3410     {
3411         BOOL capsOn=0;
3412
3413         /* helg: clear CAPS LOCK state if caps lock switches to cyrillic */
3414         if(cfg.xlat_capslockcyr && keystate[VK_CAPITAL] != 0) {
3415             capsOn= !left_alt;
3416             keystate[VK_CAPITAL] = 0;
3417         }
3418
3419         r = ToAsciiEx(wParam, scan, keystate, keys, 0, kbd_layout);
3420 #ifdef SHOW_TOASCII_RESULT
3421         if (r == 1 && !key_down) {
3422             if (alt_sum) {
3423                 if (in_utf || dbcs_screenfont)
3424                     debug((", (U+%04x)", alt_sum));
3425                 else
3426                     debug((", LCH(%d)", alt_sum));
3427             } else {
3428                 debug((", ACH(%d)", keys[0]));
3429             }
3430         } else if (r > 0) {
3431             int r1;
3432             debug((", ASC("));
3433             for (r1 = 0; r1 < r; r1++) {
3434                 debug(("%s%d", r1 ? "," : "", keys[r1]));
3435             }
3436             debug((")"));
3437         }
3438 #endif
3439         if (r > 0) {
3440             WCHAR keybuf;
3441
3442             /*
3443              * Interrupt an ongoing paste. I'm not sure this is
3444              * sensible, but for the moment it's preferable to
3445              * having to faff about buffering things.
3446              */
3447             term_nopaste();
3448
3449             p = output;
3450             for (i = 0; i < r; i++) {
3451                 unsigned char ch = (unsigned char) keys[i];
3452
3453                 if (compose_state == 2 && (ch & 0x80) == 0 && ch > ' ') {
3454                     compose_char = ch;
3455                     compose_state++;
3456                     continue;
3457                 }
3458                 if (compose_state == 3 && (ch & 0x80) == 0 && ch > ' ') {
3459                     int nc;
3460                     compose_state = 0;
3461
3462                     if ((nc = check_compose(compose_char, ch)) == -1) {
3463                         MessageBeep(MB_ICONHAND);
3464                         return 0;
3465                     }
3466                     keybuf = nc;
3467                     luni_send(&keybuf, 1, 1);
3468                     continue;
3469                 }
3470
3471                 compose_state = 0;
3472
3473                 if (!key_down) {
3474                     if (alt_sum) {
3475                         if (in_utf || dbcs_screenfont) {
3476                             keybuf = alt_sum;
3477                             luni_send(&keybuf, 1, 1);
3478                         } else {
3479                             ch = (char) alt_sum;
3480                             /*
3481                              * We need not bother about stdin
3482                              * backlogs here, because in GUI PuTTY
3483                              * we can't do anything about it
3484                              * anyway; there's no means of asking
3485                              * Windows to hold off on KEYDOWN
3486                              * messages. We _have_ to buffer
3487                              * everything we're sent.
3488                              */
3489                             ldisc_send(&ch, 1, 1);
3490                         }
3491                         alt_sum = 0;
3492                     } else
3493                         lpage_send(kbd_codepage, &ch, 1, 1);
3494                 } else {
3495                     if(capsOn && ch < 0x80) {
3496                         WCHAR cbuf[2];
3497                         cbuf[0] = 27;
3498                         cbuf[1] = xlat_uskbd2cyrllic(ch);
3499                         luni_send(cbuf+!left_alt, 1+!!left_alt, 1);
3500                     } else {
3501                         char cbuf[2];
3502                         cbuf[0] = '\033';
3503                         cbuf[1] = ch;
3504                         lpage_send(kbd_codepage, cbuf+!left_alt, 1+!!left_alt, 1);
3505                     }
3506                 }
3507                 show_mouseptr(0);
3508             }
3509
3510             /* This is so the ALT-Numpad and dead keys work correctly. */
3511             keys[0] = 0;
3512
3513             return p - output;
3514         }
3515         /* If we're definitly not building up an ALT-54321 then clear it */
3516         if (!left_alt)
3517             keys[0] = 0;
3518         /* If we will be using alt_sum fix the 256s */
3519         else if (keys[0] && (in_utf || dbcs_screenfont))
3520             keys[0] = 10;
3521     }
3522
3523     /*
3524      * ALT alone may or may not want to bring up the System menu.
3525      * If it's not meant to, we return 0 on presses or releases of
3526      * ALT, to show that we've swallowed the keystroke. Otherwise
3527      * we return -1, which means Windows will give the keystroke
3528      * its default handling (i.e. bring up the System menu).
3529      */
3530     if (wParam == VK_MENU && !cfg.alt_only)
3531         return 0;
3532
3533     return -1;
3534 }
3535
3536 void set_title(char *title)
3537 {
3538     sfree(window_name);
3539     window_name = smalloc(1 + strlen(title));
3540     strcpy(window_name, title);
3541     if (cfg.win_name_always || !IsIconic(hwnd))
3542         SetWindowText(hwnd, title);
3543 }
3544
3545 void set_icon(char *title)
3546 {
3547     sfree(icon_name);
3548     icon_name = smalloc(1 + strlen(title));
3549     strcpy(icon_name, title);
3550     if (!cfg.win_name_always && IsIconic(hwnd))
3551         SetWindowText(hwnd, title);
3552 }
3553
3554 void set_sbar(int total, int start, int page)
3555 {
3556     SCROLLINFO si;
3557
3558     if (!cfg.scrollbar)
3559         return;
3560
3561     si.cbSize = sizeof(si);
3562     si.fMask = SIF_ALL | SIF_DISABLENOSCROLL;
3563     si.nMin = 0;
3564     si.nMax = total - 1;
3565     si.nPage = page;
3566     si.nPos = start;
3567     if (hwnd)
3568         SetScrollInfo(hwnd, SB_VERT, &si, TRUE);
3569 }
3570
3571 Context get_ctx(void)
3572 {
3573     HDC hdc;
3574     if (hwnd) {
3575         hdc = GetDC(hwnd);
3576         if (hdc && pal)
3577             SelectPalette(hdc, pal, FALSE);
3578         return hdc;
3579     } else
3580         return NULL;
3581 }
3582
3583 void free_ctx(Context ctx)
3584 {
3585     SelectPalette(ctx, GetStockObject(DEFAULT_PALETTE), FALSE);
3586     ReleaseDC(hwnd, ctx);
3587 }
3588
3589 static void real_palette_set(int n, int r, int g, int b)
3590 {
3591     if (pal) {
3592         logpal->palPalEntry[n].peRed = r;
3593         logpal->palPalEntry[n].peGreen = g;
3594         logpal->palPalEntry[n].peBlue = b;
3595         logpal->palPalEntry[n].peFlags = PC_NOCOLLAPSE;
3596         colours[n] = PALETTERGB(r, g, b);
3597         SetPaletteEntries(pal, 0, NCOLOURS, logpal->palPalEntry);
3598     } else
3599         colours[n] = RGB(r, g, b);
3600 }
3601
3602 void palette_set(int n, int r, int g, int b)
3603 {
3604     static const int first[21] = {
3605         0, 2, 4, 6, 8, 10, 12, 14,
3606         1, 3, 5, 7, 9, 11, 13, 15,
3607         16, 17, 18, 20, 22
3608     };
3609     real_palette_set(first[n], r, g, b);
3610     if (first[n] >= 18)
3611         real_palette_set(first[n] + 1, r, g, b);
3612     if (pal) {
3613         HDC hdc = get_ctx();
3614         UnrealizeObject(pal);
3615         RealizePalette(hdc);
3616         free_ctx(hdc);
3617     }
3618 }
3619
3620 void palette_reset(void)
3621 {
3622     int i;
3623
3624     for (i = 0; i < NCOLOURS; i++) {
3625         if (pal) {
3626             logpal->palPalEntry[i].peRed = defpal[i].rgbtRed;
3627             logpal->palPalEntry[i].peGreen = defpal[i].rgbtGreen;
3628             logpal->palPalEntry[i].peBlue = defpal[i].rgbtBlue;
3629             logpal->palPalEntry[i].peFlags = 0;
3630             colours[i] = PALETTERGB(defpal[i].rgbtRed,
3631                                     defpal[i].rgbtGreen,
3632                                     defpal[i].rgbtBlue);
3633         } else
3634             colours[i] = RGB(defpal[i].rgbtRed,
3635                              defpal[i].rgbtGreen, defpal[i].rgbtBlue);
3636     }
3637
3638     if (pal) {
3639         HDC hdc;
3640         SetPaletteEntries(pal, 0, NCOLOURS, logpal->palPalEntry);
3641         hdc = get_ctx();
3642         RealizePalette(hdc);
3643         free_ctx(hdc);
3644     }
3645 }
3646
3647 void write_aclip(char *data, int len, int must_deselect)
3648 {
3649     HGLOBAL clipdata;
3650     void *lock;
3651
3652     clipdata = GlobalAlloc(GMEM_DDESHARE | GMEM_MOVEABLE, len + 1);
3653     if (!clipdata)
3654         return;
3655     lock = GlobalLock(clipdata);
3656     if (!lock)
3657         return;
3658     memcpy(lock, data, len);
3659     ((unsigned char *) lock)[len] = 0;
3660     GlobalUnlock(clipdata);
3661
3662     if (!must_deselect)
3663         SendMessage(hwnd, WM_IGNORE_CLIP, TRUE, 0);
3664
3665     if (OpenClipboard(hwnd)) {
3666         EmptyClipboard();
3667         SetClipboardData(CF_TEXT, clipdata);
3668         CloseClipboard();
3669     } else
3670         GlobalFree(clipdata);
3671
3672     if (!must_deselect)
3673         SendMessage(hwnd, WM_IGNORE_CLIP, FALSE, 0);
3674 }
3675
3676 /*
3677  * Note: unlike write_aclip() this will not append a nul.
3678  */
3679 void write_clip(wchar_t * data, int len, int must_deselect)
3680 {
3681     HGLOBAL clipdata, clipdata2, clipdata3;
3682     int len2;
3683     void *lock, *lock2, *lock3;
3684
3685     len2 = WideCharToMultiByte(CP_ACP, 0, data, len, 0, 0, NULL, NULL);
3686
3687     clipdata = GlobalAlloc(GMEM_DDESHARE | GMEM_MOVEABLE,
3688                            len * sizeof(wchar_t));
3689     clipdata2 = GlobalAlloc(GMEM_DDESHARE | GMEM_MOVEABLE, len2);
3690
3691     if (!clipdata || !clipdata2 || !clipdata3) {
3692         if (clipdata)
3693             GlobalFree(clipdata);
3694         if (clipdata2)
3695             GlobalFree(clipdata2);
3696         if (clipdata3)
3697             GlobalFree(clipdata3);
3698         return;
3699     }
3700     if (!(lock = GlobalLock(clipdata)))
3701         return;
3702     if (!(lock2 = GlobalLock(clipdata2)))
3703         return;
3704
3705     memcpy(lock, data, len * sizeof(wchar_t));
3706     WideCharToMultiByte(CP_ACP, 0, data, len, lock2, len2, NULL, NULL);
3707
3708     if (cfg.rtf_paste) {
3709         wchar_t unitab[256];
3710         char *rtf = NULL;
3711         unsigned char *tdata = (unsigned char *)lock2;
3712         wchar_t *udata = (wchar_t *)lock;
3713         int rtflen = 0, uindex = 0, tindex = 0;
3714         int rtfsize = 0;
3715         int multilen, blen, alen, totallen, i;
3716         char before[16], after[4];
3717
3718         get_unitab(CP_ACP, unitab, 0);
3719
3720         rtfsize = 100 + strlen(cfg.font);
3721         rtf = smalloc(rtfsize);
3722         sprintf(rtf, "{\\rtf1\\ansi%d{\\fonttbl\\f0\\fmodern %s;}\\f0",
3723                 GetACP(), cfg.font);
3724         rtflen = strlen(rtf);
3725
3726         /*
3727          * We want to construct a piece of RTF that specifies the
3728          * same Unicode text. To do this we will read back in
3729          * parallel from the Unicode data in `udata' and the
3730          * non-Unicode data in `tdata'. For each character in
3731          * `tdata' which becomes the right thing in `udata' when
3732          * looked up in `unitab', we just copy straight over from
3733          * tdata. For each one that doesn't, we must WCToMB it
3734          * individually and produce a \u escape sequence.
3735          *
3736          * It would probably be more robust to just bite the bullet
3737          * and WCToMB each individual Unicode character one by one,
3738          * then MBToWC each one back to see if it was an accurate
3739          * translation; but that strikes me as a horrifying number
3740          * of Windows API calls so I want to see if this faster way
3741          * will work. If it screws up badly we can always revert to
3742          * the simple and slow way.
3743          */
3744         while (tindex < len2 && uindex < len &&
3745                tdata[tindex] && udata[uindex]) {
3746             if (tindex + 1 < len2 &&
3747                 tdata[tindex] == '\r' &&
3748                 tdata[tindex+1] == '\n') {
3749                 tindex++;
3750                 uindex++;
3751             }
3752             if (unitab[tdata[tindex]] == udata[uindex]) {
3753                 multilen = 1;
3754                 before[0] = '\0';
3755                 after[0] = '\0';
3756                 blen = alen = 0;
3757             } else {
3758                 multilen = WideCharToMultiByte(CP_ACP, 0, unitab+uindex, 1,
3759                                                NULL, 0, NULL, NULL);
3760                 if (multilen != 1) {
3761                     blen = sprintf(before, "{\\uc%d\\u%d", multilen,
3762                                    udata[uindex]);
3763                     alen = 1; strcpy(after, "}");
3764                 } else {
3765                     blen = sprintf(before, "\\u%d", udata[uindex]);
3766                     alen = 0; after[0] = '\0';
3767                 }
3768             }
3769             assert(tindex + multilen <= len2);
3770             totallen = blen + alen;
3771             for (i = 0; i < multilen; i++) {
3772                 if (tdata[tindex+i] == '\\' ||
3773                     tdata[tindex+i] == '{' ||
3774                     tdata[tindex+i] == '}')
3775                     totallen += 2;
3776                 else if (tdata[tindex+i] == 0x0D || tdata[tindex+i] == 0x0A)
3777                     totallen += 6;     /* \par\r\n */
3778                 else if (tdata[tindex+i] > 0x7E || tdata[tindex+i] < 0x20)
3779                     totallen += 4;
3780                 else
3781                     totallen++;
3782             }
3783
3784             if (rtfsize < rtflen + totallen + 3) {
3785                 rtfsize = rtflen + totallen + 512;
3786                 rtf = srealloc(rtf, rtfsize);
3787             }
3788
3789             strcpy(rtf + rtflen, before); rtflen += blen;
3790             for (i = 0; i < multilen; i++) {
3791                 if (tdata[tindex+i] == '\\' ||
3792                     tdata[tindex+i] == '{' ||
3793                     tdata[tindex+i] == '}') {
3794                     rtf[rtflen++] = '\\';
3795                     rtf[rtflen++] = tdata[tindex+i];
3796                 } else if (tdata[tindex+i] == 0x0D || tdata[tindex+i] == 0x0A) {
3797                     rtflen += sprintf(rtf+rtflen, "\\par\r\n");
3798                 } else if (tdata[tindex+i] > 0x7E || tdata[tindex+i] < 0x20) {
3799                     rtflen += sprintf(rtf+rtflen, "\\'%02x", tdata[tindex+i]);
3800                 } else {
3801                     rtf[rtflen++] = tdata[tindex+i];
3802                 }
3803             }
3804             strcpy(rtf + rtflen, after); rtflen += alen;
3805
3806             tindex += multilen;
3807             uindex++;
3808         }
3809
3810         strcpy(rtf + rtflen, "}");
3811         rtflen += 2;
3812
3813         clipdata3 = GlobalAlloc(GMEM_DDESHARE | GMEM_MOVEABLE, rtflen);
3814         if (clipdata3 && (lock3 = GlobalLock(clipdata3)) != NULL) {
3815             strcpy(lock3, rtf);
3816             GlobalUnlock(clipdata3);
3817         }
3818         sfree(rtf);
3819     } else
3820         clipdata3 = NULL;
3821
3822     GlobalUnlock(clipdata);
3823     GlobalUnlock(clipdata2);
3824
3825     if (!must_deselect)
3826         SendMessage(hwnd, WM_IGNORE_CLIP, TRUE, 0);
3827
3828     if (OpenClipboard(hwnd)) {
3829         EmptyClipboard();
3830         SetClipboardData(CF_UNICODETEXT, clipdata);
3831         SetClipboardData(CF_TEXT, clipdata2);
3832         if (clipdata3)
3833             SetClipboardData(RegisterClipboardFormat(CF_RTF), clipdata3);
3834         CloseClipboard();
3835     } else {
3836         GlobalFree(clipdata);
3837         GlobalFree(clipdata2);
3838     }
3839
3840     if (!must_deselect)
3841         SendMessage(hwnd, WM_IGNORE_CLIP, FALSE, 0);
3842 }
3843
3844 void get_clip(wchar_t ** p, int *len)
3845 {
3846     static HGLOBAL clipdata = NULL;
3847     static wchar_t *converted = 0;
3848     wchar_t *p2;
3849
3850     if (converted) {
3851         sfree(converted);
3852         converted = 0;
3853     }
3854     if (!p) {
3855         if (clipdata)
3856             GlobalUnlock(clipdata);
3857         clipdata = NULL;
3858         return;
3859     } else if (OpenClipboard(NULL)) {
3860         if ((clipdata = GetClipboardData(CF_UNICODETEXT))) {
3861             CloseClipboard();
3862             *p = GlobalLock(clipdata);
3863             if (*p) {
3864                 for (p2 = *p; *p2; p2++);
3865                 *len = p2 - *p;
3866                 return;
3867             }
3868         } else if ( (clipdata = GetClipboardData(CF_TEXT)) ) {
3869             char *s;
3870             int i;
3871             CloseClipboard();
3872             s = GlobalLock(clipdata);
3873             i = MultiByteToWideChar(CP_ACP, 0, s, strlen(s) + 1, 0, 0);
3874             *p = converted = smalloc(i * sizeof(wchar_t));
3875             MultiByteToWideChar(CP_ACP, 0, s, strlen(s) + 1, converted, i);
3876             *len = i - 1;
3877             return;
3878         } else
3879             CloseClipboard();
3880     }
3881
3882     *p = NULL;
3883     *len = 0;
3884 }
3885
3886 #if 0
3887 /*
3888  * Move `lines' lines from position `from' to position `to' in the
3889  * window.
3890  */
3891 void optimised_move(int to, int from, int lines)
3892 {
3893     RECT r;
3894     int min, max;
3895
3896     min = (to < from ? to : from);
3897     max = to + from - min;
3898
3899     r.left = offset_width;
3900     r.right = offset_width + cols * font_width;
3901     r.top = offset_height + min * font_height;
3902     r.bottom = offset_height + (max + lines) * font_height;
3903     ScrollWindow(hwnd, 0, (to - from) * font_height, &r, &r);
3904 }
3905 #endif
3906
3907 /*
3908  * Print a message box and perform a fatal exit.
3909  */
3910 void fatalbox(char *fmt, ...)
3911 {
3912     va_list ap;
3913     char stuff[200];
3914
3915     va_start(ap, fmt);
3916     vsprintf(stuff, fmt, ap);
3917     va_end(ap);
3918     MessageBox(hwnd, stuff, "PuTTY Fatal Error", MB_ICONERROR | MB_OK);
3919     exit(1);
3920 }
3921
3922 /*
3923  * Manage window caption / taskbar flashing, if enabled.
3924  * 0 = stop, 1 = maintain, 2 = start
3925  */
3926 static void flash_window(int mode)
3927 {
3928     static long last_flash = 0;
3929     static int flashing = 0;
3930     if ((mode == 0) || (cfg.beep_ind == B_IND_DISABLED)) {
3931         /* stop */
3932         if (flashing) {
3933             FlashWindow(hwnd, FALSE);
3934             flashing = 0;
3935         }
3936
3937     } else if (mode == 2) {
3938         /* start */
3939         if (!flashing) {
3940             last_flash = GetTickCount();
3941             flashing = 1;
3942             FlashWindow(hwnd, TRUE);
3943         }
3944
3945     } else if ((mode == 1) && (cfg.beep_ind == B_IND_FLASH)) {
3946         /* maintain */
3947         if (flashing) {
3948             long now = GetTickCount();
3949             long fdiff = now - last_flash;
3950             if (fdiff < 0 || fdiff > 450) {
3951                 last_flash = now;
3952                 FlashWindow(hwnd, TRUE);        /* toggle */
3953             }
3954         }
3955     }
3956 }
3957
3958 /*
3959  * Beep.
3960  */
3961 void beep(int mode)
3962 {
3963     if (mode == BELL_DEFAULT) {
3964         /*
3965          * For MessageBeep style bells, we want to be careful of
3966          * timing, because they don't have the nice property of
3967          * PlaySound bells that each one cancels the previous
3968          * active one. So we limit the rate to one per 50ms or so.
3969          */
3970         static long lastbeep = 0;
3971         long beepdiff;
3972
3973         beepdiff = GetTickCount() - lastbeep;
3974         if (beepdiff >= 0 && beepdiff < 50)
3975             return;
3976         MessageBeep(MB_OK);
3977         /*
3978          * The above MessageBeep call takes time, so we record the
3979          * time _after_ it finishes rather than before it starts.
3980          */
3981         lastbeep = GetTickCount();
3982     } else if (mode == BELL_WAVEFILE) {
3983         if (!PlaySound(cfg.bell_wavefile, NULL, SND_ASYNC | SND_FILENAME)) {
3984             char buf[sizeof(cfg.bell_wavefile) + 80];
3985             sprintf(buf, "Unable to play sound file\n%s\n"
3986                     "Using default sound instead", cfg.bell_wavefile);
3987             MessageBox(hwnd, buf, "PuTTY Sound Error",
3988                        MB_OK | MB_ICONEXCLAMATION);
3989             cfg.beep = BELL_DEFAULT;
3990         }
3991     }
3992     /* Otherwise, either visual bell or disabled; do nothing here */
3993     if (!has_focus) {
3994         flash_window(2);               /* start */
3995     }
3996 }
3997
3998 /*
3999  * Toggle full screen mode. Thanks to cwis@nerim.fr for the
4000  * implementation.
4001  * Revised by <wez@thebrainroom.com>
4002  */
4003 static void flip_full_screen(void)
4004 {
4005     WINDOWPLACEMENT wp;
4006     LONG style;
4007
4008     wp.length = sizeof(wp);
4009     GetWindowPlacement(hwnd, &wp);
4010
4011     full_screen = !full_screen;
4012
4013     if (full_screen) {
4014         if (wp.showCmd == SW_SHOWMAXIMIZED) {
4015             /* Ooops it was already 'zoomed' we have to unzoom it before
4016              * everything will work right.
4017              */
4018             wp.showCmd = SW_SHOWNORMAL;
4019             SetWindowPlacement(hwnd, &wp);
4020         }
4021
4022         style = GetWindowLong(hwnd, GWL_STYLE) & ~WS_CAPTION;
4023         style &= ~WS_VSCROLL;
4024         if (cfg.scrollbar_in_fullscreen)
4025             style |= WS_VSCROLL;
4026         SetWindowLong(hwnd, GWL_STYLE, style);
4027
4028         /* This seems to be needed otherwize explorer doesn't notice
4029          * we want to go fullscreen and it's bar is still visible
4030          */
4031         SetWindowPos(hwnd, NULL, 0, 0, 0, 0,
4032                      SWP_NOACTIVATE | SWP_NOCOPYBITS |
4033                      SWP_NOMOVE | SWP_NOSIZE | SWP_NOZORDER |
4034                      SWP_FRAMECHANGED);
4035
4036         wp.showCmd = SW_SHOWMAXIMIZED;
4037         SetWindowPlacement(hwnd, &wp);
4038     } else {
4039         style = GetWindowLong(hwnd, GWL_STYLE) | WS_CAPTION;
4040         style &= ~WS_VSCROLL;
4041         if (cfg.scrollbar)
4042             style |= WS_VSCROLL;
4043         SetWindowLong(hwnd, GWL_STYLE, style);
4044
4045         /* Don't need to do a SetWindowPos as the resize will force a
4046          * full redraw.
4047          */
4048         wp.showCmd = SW_SHOWNORMAL;
4049         SetWindowPlacement(hwnd, &wp);
4050     }
4051
4052     CheckMenuItem(GetSystemMenu(hwnd, FALSE), IDM_FULLSCREEN,
4053                   MF_BYCOMMAND| full_screen ? MF_CHECKED : MF_UNCHECKED);
4054 }