window.c

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