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