14 #define PUTTY_DO_GLOBALS /* actually _define_ globals */
18 #define IDM_SHOWLOG 0x0010
19 #define IDM_NEWSESS 0x0020
20 #define IDM_DUPSESS 0x0030
21 #define IDM_RECONF 0x0040
22 #define IDM_CLRSB 0x0050
23 #define IDM_RESET 0x0060
24 #define IDM_TEL_AYT 0x0070
25 #define IDM_TEL_BRK 0x0080
26 #define IDM_TEL_SYNCH 0x0090
27 #define IDM_TEL_EC 0x00a0
28 #define IDM_TEL_EL 0x00b0
29 #define IDM_TEL_GA 0x00c0
30 #define IDM_TEL_NOP 0x00d0
31 #define IDM_TEL_ABORT 0x00e0
32 #define IDM_TEL_AO 0x00f0
33 #define IDM_TEL_IP 0x0100
34 #define IDM_TEL_SUSP 0x0110
35 #define IDM_TEL_EOR 0x0120
36 #define IDM_TEL_EOF 0x0130
37 #define IDM_ABOUT 0x0140
38 #define IDM_SAVEDSESS 0x0150
40 #define IDM_SAVED_MIN 0x1000
41 #define IDM_SAVED_MAX 0x2000
43 #define WM_IGNORE_SIZE (WM_XUSER + 1)
44 #define WM_IGNORE_CLIP (WM_XUSER + 2)
45 #define WM_IGNORE_KEYMENU (WM_XUSER + 3)
47 static LRESULT CALLBACK WndProc (HWND, UINT, WPARAM, LPARAM);
48 static int TranslateKey(UINT message, WPARAM wParam, LPARAM lParam, unsigned char *output);
49 static void cfgtopalette(void);
50 static void init_palette(void);
51 static void init_fonts(int);
53 static int extra_width, extra_height;
55 static int pending_netevent = 0;
56 static WPARAM pend_netevent_wParam = 0;
57 static LPARAM pend_netevent_lParam = 0;
58 static void enact_pending_netevent(void);
62 #define FONT_UNDERLINE 2
63 #define FONT_BOLDUND 3
65 #define FONT_OEMBOLD 5
66 #define FONT_OEMBOLDUND 6
68 static HFONT fonts[8];
69 static int font_needs_hand_underlining;
71 BOLD_COLOURS, BOLD_SHADOW, BOLD_FONT
79 static COLORREF colours[NCOLOURS];
81 static LPLOGPALETTE logpal;
82 static RGBTRIPLE defpal[NCOLOURS];
86 static int dbltime, lasttime, lastact;
87 static Mouse_Button lastbtn;
89 static char *window_name, *icon_name;
91 static Ldisc *real_ldisc;
93 void begin_session(void) {
97 int WINAPI WinMain(HINSTANCE inst, HINSTANCE prev, LPSTR cmdline, int show) {
98 static char appname[] = "PuTTY";
103 int guess_width, guess_height;
106 flags = FLAG_VERBOSE | FLAG_INTERACTIVE;
108 winsock_ver = MAKEWORD(1, 1);
109 if (WSAStartup(winsock_ver, &wsadata)) {
110 MessageBox(NULL, "Unable to initialise WinSock", "WinSock Error",
111 MB_OK | MB_ICONEXCLAMATION);
114 if (LOBYTE(wsadata.wVersion) != 1 || HIBYTE(wsadata.wVersion) != 1) {
115 MessageBox(NULL, "WinSock version is incompatible with 1.1",
116 "WinSock Error", MB_OK | MB_ICONEXCLAMATION);
120 /* WISHLIST: maybe allow config tweaking even if winsock not present? */
122 InitCommonControls();
125 * Process the command line.
130 default_protocol = DEFAULT_PROTOCOL;
131 default_port = DEFAULT_PORT;
136 while (*p && isspace(*p)) p++;
139 * Process command line options first. Yes, this can be
140 * done better, and it will be as soon as I have the
144 char *q = p + strcspn(p, " \t");
147 tolower(p[0]) == 's' &&
148 tolower(p[1]) == 's' &&
149 tolower(p[2]) == 'h') {
150 default_protocol = cfg.protocol = PROT_SSH;
151 default_port = cfg.port = 22;
152 } else if (q == p + 3 &&
153 tolower(p[0]) == 'l' &&
154 tolower(p[1]) == 'o' &&
155 tolower(p[2]) == 'g') {
156 logfile = "putty.log";
158 p = q + strspn(q, " \t");
162 * An initial @ means to activate a saved session.
166 if (!*cfg.host && !do_config()) {
170 } else if (*p == '&') {
172 * An initial & means we've been given a command line
173 * containing the hex value of a HANDLE for a file
174 * mapping object, which we must then extract as a
179 if (sscanf(p+1, "%p", &filemap) == 1 &&
180 (cp = MapViewOfFile(filemap, FILE_MAP_READ,
181 0, 0, sizeof(Config))) != NULL) {
184 CloseHandle(filemap);
185 } else if (!do_config()) {
192 * If the hostname starts with "telnet:", set the
193 * protocol to Telnet and process the string as a
196 if (!strncmp(q, "telnet:", 7)) {
200 if (q[0] == '/' && q[1] == '/')
202 cfg.protocol = PROT_TELNET;
204 while (*p && *p != ':' && *p != '/') p++;
212 strncpy (cfg.host, q, sizeof(cfg.host)-1);
213 cfg.host[sizeof(cfg.host)-1] = '\0';
215 while (*p && !isspace(*p)) p++;
218 strncpy (cfg.host, q, sizeof(cfg.host)-1);
219 cfg.host[sizeof(cfg.host)-1] = '\0';
220 while (*p && isspace(*p)) p++;
235 * Select protocol. This is farmed out into a table in a
236 * separate file to enable an ssh-free variant.
241 for (i = 0; backends[i].backend != NULL; i++)
242 if (backends[i].protocol == cfg.protocol) {
243 back = backends[i].backend;
247 MessageBox(NULL, "Unsupported protocol number found",
248 "PuTTY Internal Error", MB_OK | MB_ICONEXCLAMATION);
254 real_ldisc = (cfg.ldisc_term ? &ldisc_term : &ldisc_simple);
255 /* To start with, we use the simple line discipline, so we can
256 * type passwords etc without fear of them being echoed... */
257 ldisc = &ldisc_simple;
261 wndclass.lpfnWndProc = WndProc;
262 wndclass.cbClsExtra = 0;
263 wndclass.cbWndExtra = 0;
264 wndclass.hInstance = inst;
265 wndclass.hIcon = LoadIcon (inst,
266 MAKEINTRESOURCE(IDI_MAINICON));
267 wndclass.hCursor = LoadCursor (NULL, IDC_IBEAM);
268 wndclass.hbrBackground = GetStockObject (BLACK_BRUSH);
269 wndclass.lpszMenuName = NULL;
270 wndclass.lpszClassName = appname;
272 RegisterClass (&wndclass);
277 savelines = cfg.savelines;
283 * Guess some defaults for the window size. This all gets
284 * updated later, so we don't really care too much. However, we
285 * do want the font width/height guesses to correspond to a
286 * large font rather than a small one...
293 term_size (cfg.height, cfg.width, cfg.savelines);
294 guess_width = extra_width + font_width * cols;
295 guess_height = extra_height + font_height * rows;
298 HWND w = GetDesktopWindow();
299 GetWindowRect (w, &r);
300 if (guess_width > r.right - r.left)
301 guess_width = r.right - r.left;
302 if (guess_height > r.bottom - r.top)
303 guess_height = r.bottom - r.top;
307 int winmode = WS_OVERLAPPEDWINDOW|WS_VSCROLL;
308 if (!cfg.scrollbar) winmode &= ~(WS_VSCROLL);
309 if (cfg.locksize) winmode &= ~(WS_THICKFRAME|WS_MAXIMIZEBOX);
310 hwnd = CreateWindow (appname, appname,
312 CW_USEDEFAULT, CW_USEDEFAULT,
313 guess_width, guess_height,
314 NULL, NULL, inst, NULL);
318 * Initialise the fonts, simultaneously correcting the guesses
319 * for font_{width,height}.
321 bold_mode = cfg.bold_colour ? BOLD_COLOURS : BOLD_FONT;
326 * Correct the guesses for extra_{width,height}.
330 GetWindowRect (hwnd, &wr);
331 GetClientRect (hwnd, &cr);
332 extra_width = wr.right - wr.left - cr.right + cr.left;
333 extra_height = wr.bottom - wr.top - cr.bottom + cr.top;
337 * Resize the window, now we know what size we _really_ want it
340 guess_width = extra_width + font_width * cols;
341 guess_height = extra_height + font_height * rows;
342 SendMessage (hwnd, WM_IGNORE_SIZE, 0, 0);
343 SetWindowPos (hwnd, NULL, 0, 0, guess_width, guess_height,
344 SWP_NOMOVE | SWP_NOREDRAW | SWP_NOZORDER);
347 * Initialise the scroll bar.
352 si.cbSize = sizeof(si);
353 si.fMask = SIF_ALL | SIF_DISABLENOSCROLL;
358 SetScrollInfo (hwnd, SB_VERT, &si, FALSE);
362 * Start up the telnet connection.
369 error = back->init (hwnd, cfg.host, cfg.port, &realhost);
371 sprintf(msg, "Unable to open connection:\n%s", error);
372 MessageBox(NULL, msg, "PuTTY Error", MB_ICONERROR | MB_OK);
375 window_name = icon_name = NULL;
376 sprintf(msg, "%s - PuTTY", realhost);
381 session_closed = FALSE;
384 * Set up the input and output buffers.
387 outbuf_reap = outbuf_head = 0;
390 * Prepare the mouse handler.
392 lastact = MA_NOTHING;
393 lastbtn = MB_NOTHING;
394 dbltime = GetDoubleClickTime();
397 * Set up the session-control options on the system menu.
400 HMENU m = GetSystemMenu (hwnd, FALSE);
404 AppendMenu (m, MF_SEPARATOR, 0, 0);
405 if (cfg.protocol == PROT_TELNET) {
407 AppendMenu (p, MF_ENABLED, IDM_TEL_AYT, "Are You There");
408 AppendMenu (p, MF_ENABLED, IDM_TEL_BRK, "Break");
409 AppendMenu (p, MF_ENABLED, IDM_TEL_SYNCH, "Synch");
410 AppendMenu (p, MF_SEPARATOR, 0, 0);
411 AppendMenu (p, MF_ENABLED, IDM_TEL_EC, "Erase Character");
412 AppendMenu (p, MF_ENABLED, IDM_TEL_EL, "Erase Line");
413 AppendMenu (p, MF_ENABLED, IDM_TEL_GA, "Go Ahead");
414 AppendMenu (p, MF_ENABLED, IDM_TEL_NOP, "No Operation");
415 AppendMenu (p, MF_SEPARATOR, 0, 0);
416 AppendMenu (p, MF_ENABLED, IDM_TEL_ABORT, "Abort Process");
417 AppendMenu (p, MF_ENABLED, IDM_TEL_AO, "Abort Output");
418 AppendMenu (p, MF_ENABLED, IDM_TEL_IP, "Interrupt Process");
419 AppendMenu (p, MF_ENABLED, IDM_TEL_SUSP, "Suspend Process");
420 AppendMenu (p, MF_SEPARATOR, 0, 0);
421 AppendMenu (p, MF_ENABLED, IDM_TEL_EOR, "End Of Record");
422 AppendMenu (p, MF_ENABLED, IDM_TEL_EOF, "End Of File");
423 AppendMenu (m, MF_POPUP | MF_ENABLED, (UINT) p, "Telnet Command");
424 AppendMenu (m, MF_SEPARATOR, 0, 0);
426 AppendMenu (m, MF_ENABLED, IDM_SHOWLOG, "&Event Log");
427 AppendMenu (m, MF_SEPARATOR, 0, 0);
428 AppendMenu (m, MF_ENABLED, IDM_NEWSESS, "Ne&w Session");
429 AppendMenu (m, MF_ENABLED, IDM_DUPSESS, "&Duplicate Session");
432 for (i = 1 ; i < ((nsessions < 256) ? nsessions : 256) ; i++)
433 AppendMenu (s, MF_ENABLED, IDM_SAVED_MIN + (16 * i) , sessions[i]);
434 AppendMenu (m, MF_POPUP | MF_ENABLED, (UINT) s, "Sa&ved Sessions");
435 AppendMenu (m, MF_ENABLED, IDM_RECONF, "Chan&ge Settings");
436 AppendMenu (m, MF_SEPARATOR, 0, 0);
437 AppendMenu (m, MF_ENABLED, IDM_CLRSB, "C&lear Scrollback");
438 AppendMenu (m, MF_ENABLED, IDM_RESET, "Rese&t Terminal");
439 AppendMenu (m, MF_SEPARATOR, 0, 0);
440 AppendMenu (m, MF_ENABLED, IDM_ABOUT, "&About PuTTY");
444 * Finally show the window!
446 ShowWindow (hwnd, show);
449 * Set the palette up.
455 has_focus = (GetForegroundWindow() == hwnd);
459 int timer_id = 0, long_timer = 0;
461 while (GetMessage (&msg, NULL, 0, 0) == 1) {
462 /* Sometimes DispatchMessage calls routines that use their own
463 * GetMessage loop, setup this timer so we get some control back.
465 * Also call term_update() from the timer so that if the host
466 * is sending data flat out we still do redraws.
468 if(timer_id && long_timer) {
469 KillTimer(hwnd, timer_id);
470 long_timer = timer_id = 0;
473 timer_id = SetTimer(hwnd, 1, 20, NULL);
474 DispatchMessage (&msg);
476 /* This is too fast, but I'll leave it for now 'cause it shows
477 * how often term_update is called (far too often at times!)
481 /* Send the paste buffer if there's anything to send */
484 /* If there's nothing new in the queue then we can do everything
485 * we've delayed, reading the socket, writing, and repainting
488 if (!PeekMessage (&msg, NULL, 0, 0, PM_NOREMOVE)) {
489 if (pending_netevent) {
490 enact_pending_netevent();
495 if (!PeekMessage (&msg, NULL, 0, 0, PM_NOREMOVE)) {
497 KillTimer(hwnd, timer_id);
504 timer_id = SetTimer(hwnd, 1, 2000, NULL);
505 else if (cfg.blinktext)
506 timer_id = SetTimer(hwnd, 1, 250, NULL);
508 timer_id = SetTimer(hwnd, 1, 500, NULL);
521 DeleteObject(fonts[i]);
528 if (cfg.protocol == PROT_SSH) {
539 * Print a message box and close the connection.
541 void connection_fatal(char *fmt, ...) {
546 vsprintf(stuff, fmt, ap);
548 MessageBox(hwnd, stuff, "PuTTY Fatal Error", MB_ICONERROR | MB_OK);
549 if (cfg.close_on_exit)
552 session_closed = TRUE;
553 SetWindowText (hwnd, "PuTTY (inactive)");
558 * Actually do the job requested by a WM_NETEVENT
560 static void enact_pending_netevent(void) {
562 static int reentering = 0;
565 return; /* don't unpend the pending */
567 pending_netevent = FALSE;
570 i = back->msg (pend_netevent_wParam, pend_netevent_lParam);
575 switch (WSABASEERR + (-i) % 10000) {
577 sprintf(buf, "Connection reset by peer");
580 sprintf(buf, "Unexpected network error %d", -i);
583 connection_fatal(buf);
586 if (cfg.close_on_exit)
589 session_closed = TRUE;
590 MessageBox(hwnd, "Connection closed by remote host",
591 "PuTTY", MB_OK | MB_ICONINFORMATION);
592 SetWindowText (hwnd, "PuTTY (inactive)");
598 * Copy the colour palette from the configuration data into defpal.
599 * This is non-trivial because the colour indices are different.
601 static void cfgtopalette(void) {
603 static const int ww[] = {
604 6, 7, 8, 9, 10, 11, 12, 13,
605 14, 15, 16, 17, 18, 19, 20, 21,
606 0, 1, 2, 3, 4, 4, 5, 5
609 for (i=0; i<24; i++) {
611 defpal[i].rgbtRed = cfg.colours[w][0];
612 defpal[i].rgbtGreen = cfg.colours[w][1];
613 defpal[i].rgbtBlue = cfg.colours[w][2];
618 * Set up the colour palette.
620 static void init_palette(void) {
622 HDC hdc = GetDC (hwnd);
624 if (cfg.try_palette &&
625 GetDeviceCaps (hdc, RASTERCAPS) & RC_PALETTE) {
626 logpal = smalloc(sizeof(*logpal)
627 - sizeof(logpal->palPalEntry)
628 + NCOLOURS * sizeof(PALETTEENTRY));
629 logpal->palVersion = 0x300;
630 logpal->palNumEntries = NCOLOURS;
631 for (i = 0; i < NCOLOURS; i++) {
632 logpal->palPalEntry[i].peRed = defpal[i].rgbtRed;
633 logpal->palPalEntry[i].peGreen = defpal[i].rgbtGreen;
634 logpal->palPalEntry[i].peBlue = defpal[i].rgbtBlue;
635 logpal->palPalEntry[i].peFlags = PC_NOCOLLAPSE;
637 pal = CreatePalette (logpal);
639 SelectPalette (hdc, pal, FALSE);
640 RealizePalette (hdc);
641 SelectPalette (hdc, GetStockObject (DEFAULT_PALETTE),
645 ReleaseDC (hwnd, hdc);
648 for (i=0; i<NCOLOURS; i++)
649 colours[i] = PALETTERGB(defpal[i].rgbtRed,
653 for(i=0; i<NCOLOURS; i++)
654 colours[i] = RGB(defpal[i].rgbtRed,
660 * Initialise all the fonts we will need. There may be as many as
661 * eight or as few as one. We also:
663 * - check the font width and height, correcting our guesses if
666 * - verify that the bold font is the same width as the ordinary
667 * one, and engage shadow bolding if not.
669 * - verify that the underlined font is the same width as the
670 * ordinary one (manual underlining by means of line drawing can
671 * be done in a pinch).
673 static void init_fonts(int pick_width) {
678 int fw_dontcare, fw_bold;
687 if (cfg.fontisbold) {
688 fw_dontcare = FW_BOLD;
691 fw_dontcare = FW_DONTCARE;
697 font_height = cfg.fontheight;
698 font_width = pick_width;
701 fonts[i] = CreateFont (font_height, font_width, 0, 0, w, FALSE, u, FALSE, \
702 c, OUT_DEFAULT_PRECIS, \
703 CLIP_DEFAULT_PRECIS, DEFAULT_QUALITY, \
704 FIXED_PITCH | FF_DONTCARE, cfg.font)
706 if (cfg.vtmode != VT_OEMONLY) {
707 f(FONT_NORMAL, cfg.fontcharset, fw_dontcare, FALSE);
709 SelectObject (hdc, fonts[FONT_NORMAL]);
710 GetTextMetrics(hdc, &tm);
711 font_height = tm.tmHeight;
712 font_width = tm.tmAveCharWidth;
714 f(FONT_UNDERLINE, cfg.fontcharset, fw_dontcare, TRUE);
717 * Some fonts, e.g. 9-pt Courier, draw their underlines
718 * outside their character cell. We successfully prevent
719 * screen corruption by clipping the text output, but then
720 * we lose the underline completely. Here we try to work
721 * out whether this is such a font, and if it is, we set a
722 * flag that causes underlines to be drawn by hand.
724 * Having tried other more sophisticated approaches (such
725 * as examining the TEXTMETRIC structure or requesting the
726 * height of a string), I think we'll do this the brute
727 * force way: we create a small bitmap, draw an underlined
728 * space on it, and test to see whether any pixels are
729 * foreground-coloured. (Since we expect the underline to
730 * go all the way across the character cell, we only search
731 * down a single column of the bitmap, half way across.)
735 HBITMAP und_bm, und_oldbm;
739 und_dc = CreateCompatibleDC(hdc);
740 und_bm = CreateCompatibleBitmap(hdc, font_width, font_height);
741 und_oldbm = SelectObject(und_dc, und_bm);
742 SelectObject(und_dc, fonts[FONT_UNDERLINE]);
743 SetTextAlign(und_dc, TA_TOP | TA_LEFT | TA_NOUPDATECP);
744 SetTextColor (und_dc, RGB(255,255,255));
745 SetBkColor (und_dc, RGB(0,0,0));
746 SetBkMode (und_dc, OPAQUE);
747 ExtTextOut (und_dc, 0, 0, ETO_OPAQUE, NULL, " ", 1, NULL);
749 for (i = 0; i < font_height; i++) {
750 c = GetPixel(und_dc, font_width/2, i);
754 SelectObject(und_dc, und_oldbm);
755 DeleteObject(und_bm);
757 font_needs_hand_underlining = !gotit;
760 if (bold_mode == BOLD_FONT) {
761 f(FONT_BOLD, cfg.fontcharset, fw_bold, FALSE);
762 f(FONT_BOLDUND, cfg.fontcharset, fw_bold, TRUE);
765 if (cfg.vtmode == VT_OEMANSI) {
766 f(FONT_OEM, OEM_CHARSET, fw_dontcare, FALSE);
767 f(FONT_OEMUND, OEM_CHARSET, fw_dontcare, TRUE);
769 if (bold_mode == BOLD_FONT) {
770 f(FONT_OEMBOLD, OEM_CHARSET, fw_bold, FALSE);
771 f(FONT_OEMBOLDUND, OEM_CHARSET, fw_bold, TRUE);
777 f(FONT_OEM, cfg.fontcharset, fw_dontcare, FALSE);
779 SelectObject (hdc, fonts[FONT_OEM]);
780 GetTextMetrics(hdc, &tm);
781 font_height = tm.tmHeight;
782 font_width = tm.tmAveCharWidth;
784 f(FONT_OEMUND, cfg.fontcharset, fw_dontcare, TRUE);
786 if (bold_mode == BOLD_FONT) {
787 f(FONT_BOLD, cfg.fontcharset, fw_bold, FALSE);
788 f(FONT_BOLDUND, cfg.fontcharset, fw_bold, TRUE);
793 descent = tm.tmAscent + 1;
794 if (descent >= font_height)
795 descent = font_height - 1;
796 firstchar = tm.tmFirstChar;
798 for (i=0; i<8; i++) {
800 if (SelectObject (hdc, fonts[i]) &&
801 GetTextMetrics(hdc, &tm) )
802 fsize[i] = tm.tmAveCharWidth + 256 * tm.tmHeight;
808 ReleaseDC (hwnd, hdc);
810 /* ... This is wrong in OEM only mode */
811 if (fsize[FONT_UNDERLINE] != fsize[FONT_NORMAL] ||
812 (bold_mode == BOLD_FONT &&
813 fsize[FONT_BOLDUND] != fsize[FONT_BOLD])) {
815 DeleteObject (fonts[FONT_UNDERLINE]);
816 if (bold_mode == BOLD_FONT)
817 DeleteObject (fonts[FONT_BOLDUND]);
820 if (bold_mode == BOLD_FONT &&
821 fsize[FONT_BOLD] != fsize[FONT_NORMAL]) {
822 bold_mode = BOLD_SHADOW;
823 DeleteObject (fonts[FONT_BOLD]);
824 if (und_mode == UND_FONT)
825 DeleteObject (fonts[FONT_BOLDUND]);
829 /* With the fascist font painting it doesn't matter if the linedraw font
830 * isn't exactly the right size anymore so we don't have to check this.
832 if (cfg.vtmode == VT_OEMANSI && fsize[FONT_OEM] != fsize[FONT_NORMAL] ) {
833 if( cfg.fontcharset == OEM_CHARSET )
835 MessageBox(NULL, "The OEM and ANSI versions of this font are\n"
836 "different sizes. Using OEM-only mode instead",
837 "Font Size Mismatch", MB_ICONINFORMATION | MB_OK);
838 cfg.vtmode = VT_OEMONLY;
840 else if( firstchar < ' ' )
842 MessageBox(NULL, "The OEM and ANSI versions of this font are\n"
843 "different sizes. Using XTerm mode instead",
844 "Font Size Mismatch", MB_ICONINFORMATION | MB_OK);
845 cfg.vtmode = VT_XWINDOWS;
849 MessageBox(NULL, "The OEM and ANSI versions of this font are\n"
850 "different sizes. Using ISO8859-1 mode instead",
851 "Font Size Mismatch", MB_ICONINFORMATION | MB_OK);
852 cfg.vtmode = VT_POORMAN;
857 DeleteObject (fonts[i]);
863 void request_resize (int w, int h, int refont) {
866 /* If the window is maximized supress resizing attempts */
867 if(IsZoomed(hwnd)) return;
870 /* Don't do this in OEMANSI, you may get disable messages */
871 if (refont && w != cols && (cols==80 || cols==132)
872 && cfg.vtmode != VT_OEMANSI)
874 if (refont && w != cols && (cols==80 || cols==132))
877 /* If font width too big for screen should we shrink the font more ? */
879 font_width = ((font_width*cols+w/2)/w);
886 DeleteObject(fonts[i]);
888 bold_mode = cfg.bold_colour ? BOLD_COLOURS : BOLD_FONT;
890 init_fonts(font_width);
894 static int first_time = 1;
900 /* Get the size of the screen */
901 if (GetClientRect(GetDesktopWindow(),&ss))
902 /* first_time = 0 */;
903 else { first_time = 2; break; }
905 /* Make sure the values are sane */
906 width = (ss.right-ss.left-extra_width ) / font_width;
907 height = (ss.bottom-ss.top-extra_height ) / font_height;
909 if (w>width) w=width;
910 if (h>height) h=height;
916 width = extra_width + font_width * w;
917 height = extra_height + font_height * h;
919 SetWindowPos (hwnd, NULL, 0, 0, width, height,
920 SWP_NOACTIVATE | SWP_NOCOPYBITS |
921 SWP_NOMOVE | SWP_NOZORDER);
924 static void click (Mouse_Button b, int x, int y) {
925 int thistime = GetMessageTime();
927 if (lastbtn == b && thistime - lasttime < dbltime) {
928 lastact = (lastact == MA_CLICK ? MA_2CLK :
929 lastact == MA_2CLK ? MA_3CLK :
930 lastact == MA_3CLK ? MA_CLICK : MA_NOTHING);
935 if (lastact != MA_NOTHING)
936 term_mouse (b, lastact, x, y);
940 static LRESULT CALLBACK WndProc (HWND hwnd, UINT message,
941 WPARAM wParam, LPARAM lParam) {
943 static int ignore_size = FALSE;
944 static int ignore_clip = FALSE;
945 static int ignore_keymenu = TRUE;
946 static int just_reconfigged = FALSE;
947 static int resizing = FALSE;
951 if (pending_netevent)
952 enact_pending_netevent();
960 if (!cfg.warn_on_close || session_closed ||
961 MessageBox(hwnd, "Are you sure you want to close this session?",
962 "PuTTY Exit Confirmation",
963 MB_ICONWARNING | MB_OKCANCEL) == IDOK)
970 switch (wParam & ~0xF) { /* low 4 bits reserved to Windows */
973 return 0; /* don't put up system menu on Alt */
986 PROCESS_INFORMATION pi;
987 HANDLE filemap = NULL;
989 if (wParam == IDM_DUPSESS) {
991 * Allocate a file-mapping memory chunk for the
994 SECURITY_ATTRIBUTES sa;
997 sa.nLength = sizeof(sa);
998 sa.lpSecurityDescriptor = NULL;
999 sa.bInheritHandle = TRUE;
1000 filemap = CreateFileMapping((HANDLE)0xFFFFFFFF,
1007 p = (Config *)MapViewOfFile(filemap,
1009 0, 0, sizeof(Config));
1011 *p = cfg; /* structure copy */
1015 sprintf(c, "putty &%p", filemap);
1017 } else if (wParam == IDM_SAVEDSESS) {
1018 char *session = sessions[(lParam - IDM_SAVED_MIN) / 16];
1019 cl = malloc(16 + strlen(session)); /* 8, but play safe */
1021 cl = NULL; /* not a very important failure mode */
1023 sprintf(cl, "putty @%s", session);
1029 GetModuleFileName (NULL, b, sizeof(b)-1);
1031 si.lpReserved = NULL;
1032 si.lpDesktop = NULL;
1036 si.lpReserved2 = NULL;
1037 CreateProcess (b, cl, NULL, NULL, TRUE,
1038 NORMAL_PRIORITY_CLASS, NULL, NULL, &si, &pi);
1041 CloseHandle(filemap);
1047 if (!do_reconfig(hwnd))
1049 just_reconfigged = TRUE;
1054 DeleteObject(fonts[i]);
1056 bold_mode = cfg.bold_colour ? BOLD_COLOURS : BOLD_FONT;
1057 und_mode = UND_FONT;
1060 /* Telnet will change local echo -> remote if the remote asks */
1061 if (cfg.protocol != PROT_TELNET)
1062 ldisc = (cfg.ldisc_term ? &ldisc_term : &ldisc_simple);
1070 /* Enable or disable the scroll bar, etc */
1072 LONG nflg, flag = GetWindowLong(hwnd, GWL_STYLE);
1075 if (cfg.scrollbar) nflg |= WS_VSCROLL;
1076 else nflg &= ~WS_VSCROLL;
1078 nflg &= ~(WS_THICKFRAME|WS_MAXIMIZEBOX);
1080 nflg |= (WS_THICKFRAME|WS_MAXIMIZEBOX);
1086 SetWindowLong(hwnd, GWL_STYLE, nflg);
1087 SendMessage (hwnd, WM_IGNORE_SIZE, 0, 0);
1088 SetWindowPos(hwnd, NULL, 0,0,0,0,
1089 SWP_NOACTIVATE|SWP_NOCOPYBITS|
1090 SWP_NOMOVE|SWP_NOSIZE| SWP_NOZORDER|
1093 GetWindowRect (hwnd, &wr);
1094 GetClientRect (hwnd, &cr);
1095 extra_width = wr.right - wr.left - cr.right + cr.left;
1096 extra_height = wr.bottom - wr.top - cr.bottom + cr.top;
1100 term_size(cfg.height, cfg.width, cfg.savelines);
1101 InvalidateRect(hwnd, NULL, TRUE);
1102 SetWindowPos (hwnd, NULL, 0, 0,
1103 extra_width + font_width * cfg.width,
1104 extra_height + font_height * cfg.height,
1105 SWP_NOACTIVATE | SWP_NOCOPYBITS |
1106 SWP_NOMOVE | SWP_NOZORDER);
1107 if (IsIconic(hwnd)) {
1108 SetWindowText (hwnd,
1109 cfg.win_name_always ? window_name : icon_name);
1118 case IDM_TEL_AYT: back->special (TS_AYT); break;
1119 case IDM_TEL_BRK: back->special (TS_BRK); break;
1120 case IDM_TEL_SYNCH: back->special (TS_SYNCH); break;
1121 case IDM_TEL_EC: back->special (TS_EC); break;
1122 case IDM_TEL_EL: back->special (TS_EL); break;
1123 case IDM_TEL_GA: back->special (TS_GA); break;
1124 case IDM_TEL_NOP: back->special (TS_NOP); break;
1125 case IDM_TEL_ABORT: back->special (TS_ABORT); break;
1126 case IDM_TEL_AO: back->special (TS_AO); break;
1127 case IDM_TEL_IP: back->special (TS_IP); break;
1128 case IDM_TEL_SUSP: back->special (TS_SUSP); break;
1129 case IDM_TEL_EOR: back->special (TS_EOR); break;
1130 case IDM_TEL_EOF: back->special (TS_EOF); break;
1135 if (wParam >= IDM_SAVED_MIN && wParam <= IDM_SAVED_MAX) {
1136 SendMessage(hwnd, WM_SYSCOMMAND, IDM_SAVEDSESS, wParam);
1141 #define X_POS(l) ((int)(short)LOWORD(l))
1142 #define Y_POS(l) ((int)(short)HIWORD(l))
1144 #define TO_CHR_X(x) (((x)<0 ? (x)-font_width+1 : (x)) / font_width)
1145 #define TO_CHR_Y(y) (((y)<0 ? (y)-font_height+1: (y)) / font_height)
1147 case WM_LBUTTONDOWN:
1148 click (MB_SELECT, TO_CHR_X(X_POS(lParam)),
1149 TO_CHR_Y(Y_POS(lParam)));
1153 term_mouse (MB_SELECT, MA_RELEASE, TO_CHR_X(X_POS(lParam)),
1154 TO_CHR_Y(Y_POS(lParam)));
1157 case WM_MBUTTONDOWN:
1159 click (cfg.mouse_is_xterm ? MB_PASTE : MB_EXTEND,
1160 TO_CHR_X(X_POS(lParam)),
1161 TO_CHR_Y(Y_POS(lParam)));
1164 term_mouse (cfg.mouse_is_xterm ? MB_PASTE : MB_EXTEND,
1165 MA_RELEASE, TO_CHR_X(X_POS(lParam)),
1166 TO_CHR_Y(Y_POS(lParam)));
1169 case WM_RBUTTONDOWN:
1171 click (cfg.mouse_is_xterm ? MB_EXTEND : MB_PASTE,
1172 TO_CHR_X(X_POS(lParam)),
1173 TO_CHR_Y(Y_POS(lParam)));
1176 term_mouse (cfg.mouse_is_xterm ? MB_EXTEND : MB_PASTE,
1177 MA_RELEASE, TO_CHR_X(X_POS(lParam)),
1178 TO_CHR_Y(Y_POS(lParam)));
1183 * Add the mouse position and message time to the random
1184 * number noise, if we're using ssh.
1186 if (cfg.protocol == PROT_SSH)
1187 noise_ultralight(lParam);
1189 if (wParam & (MK_LBUTTON | MK_MBUTTON | MK_RBUTTON)) {
1191 if (wParam & MK_LBUTTON)
1193 else if (wParam & MK_MBUTTON)
1194 b = cfg.mouse_is_xterm ? MB_PASTE : MB_EXTEND;
1196 b = cfg.mouse_is_xterm ? MB_EXTEND : MB_PASTE;
1197 term_mouse (b, MA_DRAG, TO_CHR_X(X_POS(lParam)),
1198 TO_CHR_Y(Y_POS(lParam)));
1201 case WM_IGNORE_CLIP:
1202 ignore_clip = wParam; /* don't panic on DESTROYCLIPBOARD */
1204 case WM_IGNORE_KEYMENU:
1205 ignore_keymenu = wParam; /* do or don't ignore SC_KEYMENU */
1207 case WM_DESTROYCLIPBOARD:
1210 ignore_clip = FALSE;
1215 hdc = BeginPaint (hwnd, &p);
1217 SelectPalette (hdc, pal, TRUE);
1218 RealizePalette (hdc);
1220 term_paint (hdc, p.rcPaint.left, p.rcPaint.top,
1221 p.rcPaint.right, p.rcPaint.bottom);
1222 SelectObject (hdc, GetStockObject(SYSTEM_FONT));
1223 SelectObject (hdc, GetStockObject(WHITE_PEN));
1224 EndPaint (hwnd, &p);
1228 /* Notice we can get multiple netevents, FD_READ, FD_WRITE etc
1229 * but the only one that's likely to try to overload us is FD_READ.
1230 * This means buffering just one is fine.
1232 if (pending_netevent)
1233 enact_pending_netevent();
1235 pending_netevent = TRUE;
1236 pend_netevent_wParam=wParam;
1237 pend_netevent_lParam=lParam;
1249 case WM_IGNORE_SIZE:
1250 ignore_size = TRUE; /* don't panic on next WM_SIZE msg */
1252 case WM_ENTERSIZEMOVE:
1256 case WM_EXITSIZEMOVE:
1263 int width, height, w, h, ew, eh;
1264 LPRECT r = (LPRECT)lParam;
1266 width = r->right - r->left - extra_width;
1267 height = r->bottom - r->top - extra_height;
1268 w = (width + font_width/2) / font_width; if (w < 1) w = 1;
1269 h = (height + font_height/2) / font_height; if (h < 1) h = 1;
1270 UpdateSizeTip(hwnd, w, h);
1271 ew = width - w * font_width;
1272 eh = height - h * font_height;
1274 if (wParam == WMSZ_LEFT ||
1275 wParam == WMSZ_BOTTOMLEFT ||
1276 wParam == WMSZ_TOPLEFT)
1282 if (wParam == WMSZ_TOP ||
1283 wParam == WMSZ_TOPRIGHT ||
1284 wParam == WMSZ_TOPLEFT)
1294 /* break; (never reached) */
1296 if (wParam == SIZE_MINIMIZED) {
1297 SetWindowText (hwnd,
1298 cfg.win_name_always ? window_name : icon_name);
1301 if (wParam == SIZE_RESTORED || wParam == SIZE_MAXIMIZED)
1302 SetWindowText (hwnd, window_name);
1304 int width, height, w, h;
1305 #if 0 /* we have fixed this using WM_SIZING now */
1309 width = LOWORD(lParam);
1310 height = HIWORD(lParam);
1311 w = width / font_width; if (w < 1) w = 1;
1312 h = height / font_height; if (h < 1) h = 1;
1313 #if 0 /* we have fixed this using WM_SIZING now */
1314 ew = width - w * font_width;
1315 eh = height - h * font_height;
1316 if (ew != 0 || eh != 0) {
1318 GetWindowRect (hwnd, &r);
1319 SendMessage (hwnd, WM_IGNORE_SIZE, 0, 0);
1320 SetWindowPos (hwnd, NULL, 0, 0,
1321 r.right - r.left - ew, r.bottom - r.top - eh,
1322 SWP_NOACTIVATE | SWP_NOMOVE | SWP_NOZORDER);
1325 if (w != cols || h != rows || just_reconfigged) {
1327 term_size (h, w, cfg.savelines);
1329 * Don't call back->size in mid-resize. (To prevent
1330 * massive numbers of resize events getting sent
1331 * down the connection during an NT opaque drag.)
1335 just_reconfigged = FALSE;
1338 ignore_size = FALSE;
1341 switch (LOWORD(wParam)) {
1342 case SB_BOTTOM: term_scroll(-1, 0); break;
1343 case SB_TOP: term_scroll(+1, 0); break;
1344 case SB_LINEDOWN: term_scroll (0, +1); break;
1345 case SB_LINEUP: term_scroll (0, -1); break;
1346 case SB_PAGEDOWN: term_scroll (0, +rows/2); break;
1347 case SB_PAGEUP: term_scroll (0, -rows/2); break;
1348 case SB_THUMBPOSITION: case SB_THUMBTRACK:
1349 term_scroll (1, HIWORD(wParam)); break;
1352 case WM_PALETTECHANGED:
1353 if ((HWND) wParam != hwnd && pal != NULL) {
1354 HDC hdc = get_ctx();
1356 if (RealizePalette (hdc) > 0)
1362 case WM_QUERYNEWPALETTE:
1364 HDC hdc = get_ctx();
1366 if (RealizePalette (hdc) > 0)
1378 * Add the scan code and keypress timing to the random
1379 * number noise, if we're using ssh.
1381 if (cfg.protocol == PROT_SSH)
1382 noise_ultralight(lParam);
1385 * We don't do TranslateMessage since it disassociates the
1386 * resulting CHAR message from the KEYDOWN that sparked it,
1387 * which we occasionally don't want. Instead, we process
1388 * KEYDOWN, and call the Win32 translator functions so that
1389 * we get the translations under _our_ control.
1392 unsigned char buf[20];
1395 len = TranslateKey (message, wParam, lParam, buf);
1397 return DefWindowProc (hwnd, message, wParam, lParam);
1398 ldisc->send (buf, len);
1404 * Nevertheless, we are prepared to deal with WM_CHAR
1405 * messages, should they crop up. So if someone wants to
1406 * post the things to us as part of a macro manoeuvre,
1407 * we're ready to cope.
1410 char c = xlat_kbd2tty((unsigned char)wParam);
1411 ldisc->send (&c, 1);
1416 return DefWindowProc (hwnd, message, wParam, lParam);
1420 * Draw a line of text in the window, at given character
1421 * coordinates, in given attributes.
1423 * We are allowed to fiddle with the contents of `text'.
1425 void do_text (Context ctx, int x, int y, char *text, int len,
1426 unsigned long attr, int lattr) {
1428 int nfg, nbg, nfont;
1431 int force_manual_underline = 0;
1432 int fnt_width = font_width*(1+(lattr!=LATTR_NORM));
1433 static int *IpDx = 0, IpDxLEN = 0;;
1435 if (len>IpDxLEN || IpDx[0] != fnt_width) {
1439 IpDx = smalloc((len+16)*sizeof(int));
1442 for(i=0; i<IpDxLEN; i++)
1443 IpDx[i] = fnt_width;
1449 if (attr & ATTR_ACTCURS) {
1450 attr &= (bold_mode == BOLD_COLOURS ? 0x300200 : 0x300300);
1451 attr ^= ATTR_CUR_XOR;
1455 if (cfg.vtmode == VT_OEMONLY)
1459 * Map high-half characters in order to approximate ISO using
1460 * OEM character set. No characters are missing if the OEM codepage
1463 if (nfont & FONT_OEM) {
1465 for (i=0; i<len; i++)
1466 if (text[i] >= '\xA0' && text[i] <= '\xFF') {
1468 /* This is CP850 ... perfect translation */
1469 static const char oemhighhalf[] =
1470 "\x20\xAD\xBD\x9C\xCF\xBE\xDD\xF5" /* A0-A7 */
1471 "\xF9\xB8\xA6\xAE\xAA\xF0\xA9\xEE" /* A8-AF */
1472 "\xF8\xF1\xFD\xFC\xEF\xE6\xF4\xFA" /* B0-B7 */
1473 "\xF7\xFB\xA7\xAF\xAC\xAB\xF3\xA8" /* B8-BF */
1474 "\xB7\xB5\xB6\xC7\x8E\x8F\x92\x80" /* C0-C7 */
1475 "\xD4\x90\xD2\xD3\xDE\xD6\xD7\xD8" /* C8-CF */
1476 "\xD1\xA5\xE3\xE0\xE2\xE5\x99\x9E" /* D0-D7 */
1477 "\x9D\xEB\xE9\xEA\x9A\xED\xE8\xE1" /* D8-DF */
1478 "\x85\xA0\x83\xC6\x84\x86\x91\x87" /* E0-E7 */
1479 "\x8A\x82\x88\x89\x8D\xA1\x8C\x8B" /* E8-EF */
1480 "\xD0\xA4\x95\xA2\x93\xE4\x94\xF6" /* F0-F7 */
1481 "\x9B\x97\xA3\x96\x81\xEC\xE7\x98" /* F8-FF */
1484 /* This is CP437 ... junk translation */
1485 static const unsigned char oemhighhalf[] = {
1486 0xff, 0xad, 0x9b, 0x9c, 0x6f, 0x9d, 0x7c, 0x15,
1487 0x22, 0x43, 0xa6, 0xae, 0xaa, 0x2d, 0x52, 0xc4,
1488 0xf8, 0xf1, 0xfd, 0x33, 0x27, 0xe6, 0x14, 0xfa,
1489 0x2c, 0x31, 0xa7, 0xaf, 0xac, 0xab, 0x2f, 0xa8,
1490 0x41, 0x41, 0x41, 0x41, 0x8e, 0x8f, 0x92, 0x80,
1491 0x45, 0x90, 0x45, 0x45, 0x49, 0x49, 0x49, 0x49,
1492 0x44, 0xa5, 0x4f, 0x4f, 0x4f, 0x4f, 0x99, 0x78,
1493 0xed, 0x55, 0x55, 0x55, 0x9a, 0x59, 0x50, 0xe1,
1494 0x85, 0xa0, 0x83, 0x61, 0x84, 0x86, 0x91, 0x87,
1495 0x8a, 0x82, 0x88, 0x89, 0x8d, 0xa1, 0x8c, 0x8b,
1496 0x0b, 0xa4, 0x95, 0xa2, 0x93, 0x6f, 0x94, 0xf6,
1497 0xed, 0x97, 0xa3, 0x96, 0x81, 0x79, 0x70, 0x98
1500 text[i] = oemhighhalf[(unsigned char)text[i] - 0xA0];
1504 if (attr & ATTR_GBCHR) {
1507 * GB mapping: map # to pound, and everything else stays
1510 for (i=0; i<len; i++)
1512 text[i] = cfg.vtmode == VT_OEMONLY ? '\x9C' : '\xA3';
1513 } else if (attr & ATTR_LINEDRW) {
1516 static const char poorman[] =
1517 "*#****\xB0\xB1**+++++-----++++|****\xA3\xB7";
1520 static const char oemmap_437[] =
1521 "\x04\xB1****\xF8\xF1**\xD9\xBF\xDA\xC0\xC5"
1522 "\xC4\xC4\xC4\xC4\xC4\xC3\xB4\xC1\xC2\xB3\xF3\xF2\xE3*\x9C\xFA";
1525 static const char oemmap_850[] =
1526 "\x04\xB1****\xF8\xF1**\xD9\xBF\xDA\xC0\xC5"
1527 "\xC4\xC4\xC4\xC4\xC4\xC3\xB4\xC1\xC2\xB3****\x9C\xFA";
1529 /* Poor windows font ... eg: windows courier */
1530 static const char oemmap[] =
1531 "*\xB1****\xF8\xF1**\xD9\xBF\xDA\xC0\xC5"
1532 "\xC4\xC4\xC4\xC4\xC4\xC3\xB4\xC1\xC2\xB3****\x9C\xFA";
1535 * Line drawing mapping: map ` thru ~ (0x60 thru 0x7E) to
1536 * VT100 line drawing chars; everything else stays normal.
1538 switch (cfg.vtmode) {
1540 for (i=0; i<len; i++)
1541 if (text[i] >= '\x60' && text[i] <= '\x7E')
1542 text[i] += '\x01' - '\x60';
1545 /* Make sure we actually have an OEM font */
1546 if (fonts[nfont|FONT_OEM]) {
1549 for (i=0; i<len; i++)
1550 if (text[i] >= '\x60' && text[i] <= '\x7E')
1551 text[i] = oemmap[(unsigned char)text[i] - 0x60];
1555 for (i=0; i<len; i++)
1556 if (text[i] >= '\x60' && text[i] <= '\x7E')
1557 text[i] = poorman[(unsigned char)text[i] - 0x60];
1562 nfg = 2 * ((attr & ATTR_FGMASK) >> ATTR_FGSHIFT);
1563 nbg = 2 * ((attr & ATTR_BGMASK) >> ATTR_BGSHIFT);
1564 if (bold_mode == BOLD_FONT && (attr & ATTR_BOLD))
1566 if (und_mode == UND_FONT && (attr & ATTR_UNDER))
1567 nfont |= FONT_UNDERLINE;
1570 if (nfont&FONT_UNDERLINE)
1571 force_manual_underline = 1;
1572 /* Don't do the same for manual bold, it could be bad news. */
1574 nfont &= ~(FONT_BOLD|FONT_UNDERLINE);
1576 if (font_needs_hand_underlining && (attr & ATTR_UNDER))
1577 force_manual_underline = 1;
1578 if (attr & ATTR_REVERSE) {
1579 t = nfg; nfg = nbg; nbg = t;
1581 if (bold_mode == BOLD_COLOURS && (attr & ATTR_BOLD))
1583 if (bold_mode == BOLD_COLOURS && (attr & ATTR_BLINK))
1587 SelectObject (hdc, fonts[nfont]);
1588 SetTextColor (hdc, fg);
1589 SetBkColor (hdc, bg);
1590 SetBkMode (hdc, OPAQUE);
1593 line_box.right = x+fnt_width*len;
1594 line_box.bottom = y+font_height;
1595 ExtTextOut (hdc, x, y, ETO_CLIPPED|ETO_OPAQUE, &line_box, text, len, IpDx);
1596 if (bold_mode == BOLD_SHADOW && (attr & ATTR_BOLD)) {
1597 SetBkMode (hdc, TRANSPARENT);
1599 /* GRR: This draws the character outside it's box and can leave
1600 * 'droppings' even with the clip box! I suppose I could loop it
1601 * one character at a time ... yuk.
1603 * Or ... I could do a test print with "W", and use +1 or -1 for this
1604 * shift depending on if the leftmost column is blank...
1606 ExtTextOut (hdc, x-1, y, ETO_CLIPPED, &line_box, text, len, IpDx);
1608 if (force_manual_underline ||
1609 (und_mode == UND_LINE && (attr & ATTR_UNDER))) {
1611 oldpen = SelectObject (hdc, CreatePen(PS_SOLID, 0, fg));
1612 MoveToEx (hdc, x, y+descent, NULL);
1613 LineTo (hdc, x+len*fnt_width, y+descent);
1614 oldpen = SelectObject (hdc, oldpen);
1615 DeleteObject (oldpen);
1617 if (attr & ATTR_PASCURS) {
1620 pts[0].x = pts[1].x = pts[4].x = x;
1621 pts[2].x = pts[3].x = x+fnt_width-1;
1622 pts[0].y = pts[3].y = pts[4].y = y;
1623 pts[1].y = pts[2].y = y+font_height-1;
1624 oldpen = SelectObject (hdc, CreatePen(PS_SOLID, 0, colours[23]));
1625 Polyline (hdc, pts, 5);
1626 oldpen = SelectObject (hdc, oldpen);
1627 DeleteObject (oldpen);
1631 static int check_compose(int first, int second) {
1633 static char * composetbl[] = {
1634 "++#", "AA@", "(([", "//\\", "))]", "(-{", "-)}", "/^|", "!!¡", "C/¢",
1635 "C|¢", "L-£", "L=£", "XO¤", "X0¤", "Y-¥", "Y=¥", "||¦", "SO§", "S!§",
1636 "S0§", "\"\"¨", "CO©", "C0©", "A_ª", "<<«", ",-¬", "--", "RO®",
1637 "-^¯", "0^°", "+-±", "2^²", "3^³", "''´", "/Uµ", "P!¶", ".^·", ",,¸",
1638 "1^¹", "O_º", ">>»", "14¼", "12½", "34¾", "??¿", "`AÀ", "'AÁ", "^AÂ",
1639 "~AÃ", "\"AÄ", "*AÅ", "AEÆ", ",CÇ", "`EÈ", "'EÉ", "^EÊ", "\"EË",
1640 "`IÌ", "'IÍ", "^IÎ", "\"IÏ", "-DÐ", "~NÑ", "`OÒ", "'OÓ", "^OÔ",
1641 "~OÕ", "\"OÖ", "XX×", "/OØ", "`UÙ", "'UÚ", "^UÛ", "\"UÜ", "'YÝ",
1642 "HTÞ", "ssß", "`aà", "'aá", "^aâ", "~aã", "\"aä", "*aå", "aeæ", ",cç",
1643 "`eè", "'eé", "^eê", "\"eë", "`iì", "'ií", "^iî", "\"iï", "-dð", "~nñ",
1644 "`oò", "'oó", "^oô", "~oõ", "\"oö", ":-÷", "o/ø", "`uù", "'uú", "^uû",
1645 "\"uü", "'yý", "htþ", "\"yÿ",
1649 static int recurse = 0;
1656 sprintf(buf, "cc(%d,%d)", first, second);
1661 for(c=composetbl; *c; c++) {
1662 if( (*c)[0] == first && (*c)[1] == second)
1664 return (*c)[2] & 0xFF;
1671 nc = check_compose(second, first);
1673 nc = check_compose(toupper(first), toupper(second));
1675 nc = check_compose(toupper(second), toupper(first));
1683 * Translate a WM_(SYS)?KEY(UP|DOWN) message into a string of ASCII
1684 * codes. Returns number of bytes used or zero to drop the message
1685 * or -1 to forward the message to windows.
1687 static int TranslateKey(UINT message, WPARAM wParam, LPARAM lParam, unsigned char *output) {
1689 int scan, left_alt = 0, key_down, shift_state;
1691 unsigned char * p = output;
1693 static WORD keys[3];
1694 static int compose_state = 0;
1695 static int compose_char = 0;
1696 static WPARAM compose_key = 0;
1698 r = GetKeyboardState(keystate);
1699 if (!r) memset(keystate, 0, sizeof(keystate));
1702 /* Note if AltGr was pressed and if it was used as a compose key */
1703 if (wParam == VK_MENU && (HIWORD(lParam)&KF_EXTENDED))
1705 keystate[VK_RMENU] = keystate[VK_MENU];
1706 if (!compose_state) compose_key = wParam;
1708 if (wParam == VK_APPS && !compose_state)
1709 compose_key = wParam;
1711 if (wParam == compose_key)
1713 if (compose_state == 0 && (HIWORD(lParam)&(KF_UP|KF_REPEAT))==0)
1715 else if (compose_state == 1 && (HIWORD(lParam)&KF_UP))
1720 else if (compose_state==1 && wParam != VK_CONTROL)
1723 /* Nastyness with NUMLock - Shift-NUMLock is left alone though */
1724 if ( (cfg.funky_type == 0 || (cfg.funky_type == 1 && app_keypad_keys))
1725 && wParam==VK_NUMLOCK && !(keystate[VK_SHIFT]&0x80)) {
1727 wParam = VK_EXECUTE;
1729 /* UnToggle NUMLock */
1730 if ((HIWORD(lParam)&(KF_UP|KF_REPEAT))==0)
1731 keystate[VK_NUMLOCK] ^= 1;
1734 /* And write back the 'adjusted' state */
1735 SetKeyboardState (keystate);
1738 /* Disable Auto repeat if required */
1739 if (repeat_off && (HIWORD(lParam)&(KF_UP|KF_REPEAT))==KF_REPEAT)
1742 if ((HIWORD(lParam)&KF_ALTDOWN) && (keystate[VK_RMENU]&0x80) == 0)
1745 key_down = ((HIWORD(lParam)&KF_UP)==0);
1747 /* Make sure Ctrl-ALT is not the same as AltGr for ToAscii */
1748 if (left_alt && (keystate[VK_CONTROL]&0x80))
1749 keystate[VK_MENU] = 0;
1751 scan = (HIWORD(lParam) & (KF_UP | KF_EXTENDED | 0xFF));
1752 shift_state = ((keystate[VK_SHIFT]&0x80)!=0)
1753 + ((keystate[VK_CONTROL]&0x80)!=0)*2;
1756 * Record that we pressed key so the scroll window can be reset, but
1757 * be careful to avoid Shift-UP/Down
1759 if( wParam != VK_SHIFT && wParam != VK_PRIOR && wParam != VK_NEXT ) {
1763 /* Make sure we're not pasting */
1764 if (key_down) term_nopaste();
1766 if (compose_state>1 && left_alt) compose_state = 0;
1768 /* Sanitize the number pad if not using a PC NumPad */
1769 if( left_alt || (app_keypad_keys && cfg.funky_type != 2)
1770 || cfg.nethack_keypad || compose_state )
1772 if ((HIWORD(lParam)&KF_EXTENDED) == 0)
1777 case VK_INSERT: nParam = VK_NUMPAD0; break;
1778 case VK_END: nParam = VK_NUMPAD1; break;
1779 case VK_DOWN: nParam = VK_NUMPAD2; break;
1780 case VK_NEXT: nParam = VK_NUMPAD3; break;
1781 case VK_LEFT: nParam = VK_NUMPAD4; break;
1782 case VK_CLEAR: nParam = VK_NUMPAD5; break;
1783 case VK_RIGHT: nParam = VK_NUMPAD6; break;
1784 case VK_HOME: nParam = VK_NUMPAD7; break;
1785 case VK_UP: nParam = VK_NUMPAD8; break;
1786 case VK_PRIOR: nParam = VK_NUMPAD9; break;
1787 case VK_DELETE: nParam = VK_DECIMAL; break;
1791 if (keystate[VK_NUMLOCK]&1) shift_state |= 1;
1797 /* If a key is pressed and AltGr is not active */
1798 if (key_down && (keystate[VK_RMENU]&0x80) == 0 && !compose_state)
1800 /* Okay, prepare for most alts then ...*/
1801 if (left_alt) *p++ = '\033';
1803 /* Lets see if it's a pattern we know all about ... */
1804 if (wParam == VK_PRIOR && shift_state == 1) {
1805 SendMessage (hwnd, WM_VSCROLL, SB_PAGEUP, 0);
1808 if (wParam == VK_NEXT && shift_state == 1) {
1809 SendMessage (hwnd, WM_VSCROLL, SB_PAGEDOWN, 0);
1812 if (wParam == VK_INSERT && shift_state == 1) {
1813 term_mouse (MB_PASTE, MA_CLICK, 0, 0);
1814 term_mouse (MB_PASTE, MA_RELEASE, 0, 0);
1817 if (left_alt && wParam == VK_F4 && cfg.alt_f4) {
1820 if (left_alt && wParam == VK_SPACE && cfg.alt_space) {
1822 SendMessage (hwnd, WM_IGNORE_KEYMENU, FALSE, 0);
1823 SendMessage (hwnd, WM_SYSCOMMAND, SC_KEYMENU, 0);
1824 SendMessage (hwnd, WM_IGNORE_KEYMENU, TRUE, 0);
1828 /* Nethack keypad */
1829 if (cfg.nethack_keypad && !left_alt) {
1831 case VK_NUMPAD1: *p++ = shift_state ? 'B': 'b'; return p-output;
1832 case VK_NUMPAD2: *p++ = shift_state ? 'J': 'j'; return p-output;
1833 case VK_NUMPAD3: *p++ = shift_state ? 'N': 'n'; return p-output;
1834 case VK_NUMPAD4: *p++ = shift_state ? 'H': 'h'; return p-output;
1835 case VK_NUMPAD5: *p++ = shift_state ? '.': '.'; return p-output;
1836 case VK_NUMPAD6: *p++ = shift_state ? 'L': 'l'; return p-output;
1837 case VK_NUMPAD7: *p++ = shift_state ? 'Y': 'y'; return p-output;
1838 case VK_NUMPAD8: *p++ = shift_state ? 'K': 'k'; return p-output;
1839 case VK_NUMPAD9: *p++ = shift_state ? 'U': 'u'; return p-output;
1843 /* Application Keypad */
1847 if ( cfg.funky_type == 0 ||
1848 ( cfg.funky_type == 1 && app_keypad_keys)) switch(wParam) {
1849 case VK_EXECUTE: if (app_keypad_keys) xkey = 'P'; break;
1850 case VK_DIVIDE: xkey = 'Q'; break;
1851 case VK_MULTIPLY:xkey = 'R'; break;
1852 case VK_SUBTRACT:xkey = 'S'; break;
1854 if(app_keypad_keys) switch(wParam) {
1855 case VK_NUMPAD0: xkey = 'p'; break;
1856 case VK_NUMPAD1: xkey = 'q'; break;
1857 case VK_NUMPAD2: xkey = 'r'; break;
1858 case VK_NUMPAD3: xkey = 's'; break;
1859 case VK_NUMPAD4: xkey = 't'; break;
1860 case VK_NUMPAD5: xkey = 'u'; break;
1861 case VK_NUMPAD6: xkey = 'v'; break;
1862 case VK_NUMPAD7: xkey = 'w'; break;
1863 case VK_NUMPAD8: xkey = 'x'; break;
1864 case VK_NUMPAD9: xkey = 'y'; break;
1866 case VK_DECIMAL: xkey = 'n'; break;
1867 case VK_ADD: if(shift_state) xkey = 'm';
1871 if (HIWORD(lParam)&KF_EXTENDED)
1879 if (xkey>='P' && xkey<='S')
1880 p += sprintf((char *)p, "\x1B%c", xkey);
1882 p += sprintf((char *)p, "\x1B?%c", xkey);
1885 p += sprintf((char *)p, "\x1BO%c", xkey);
1890 if (wParam == VK_BACK && shift_state == 0 ) /* Backspace */
1892 *p++ = (cfg.bksp_is_delete ? 0x7F : 0x08);
1895 if (wParam == VK_TAB && shift_state == 1 ) /* Shift tab */
1897 *p++ = 0x1B; *p++ = '['; *p++ = 'Z'; return p - output;
1899 if (wParam == VK_SPACE && shift_state == 2 ) /* Ctrl-Space */
1901 *p++ = 0; return p - output;
1903 if (wParam == VK_SPACE && shift_state == 3 ) /* Ctrl-Shift-Space */
1905 *p++ = 160; return p - output;
1907 if (wParam == VK_CANCEL && shift_state == 2 ) /* Ctrl-Break */
1909 *p++ = 3; return p - output;
1911 /* Control-2 to Control-8 are special */
1912 if (shift_state == 2 && wParam >= '2' && wParam <= '8')
1914 *p++ = "\000\033\034\035\036\037\177"[wParam-'2'];
1917 if (shift_state == 2 && wParam == 0xBD) {
1921 if (shift_state == 2 && wParam == 0xDF) {
1925 if (shift_state == 0 && wParam == VK_RETURN && cr_lf_return) {
1926 *p++ = '\r'; *p++ = '\n';
1931 * Next, all the keys that do tilde codes. (ESC '[' nn '~',
1932 * for integer decimal nn.)
1934 * We also deal with the weird ones here. Linux VCs replace F1
1935 * to F5 by ESC [ [ A to ESC [ [ E. rxvt doesn't do _that_, but
1936 * does replace Home and End (1~ and 4~) by ESC [ H and ESC O w
1941 case VK_F1: code = (keystate[VK_SHIFT] & 0x80 ? 23 : 11); break;
1942 case VK_F2: code = (keystate[VK_SHIFT] & 0x80 ? 24 : 12); break;
1943 case VK_F3: code = (keystate[VK_SHIFT] & 0x80 ? 25 : 13); break;
1944 case VK_F4: code = (keystate[VK_SHIFT] & 0x80 ? 26 : 14); break;
1945 case VK_F5: code = (keystate[VK_SHIFT] & 0x80 ? 28 : 15); break;
1946 case VK_F6: code = (keystate[VK_SHIFT] & 0x80 ? 29 : 17); break;
1947 case VK_F7: code = (keystate[VK_SHIFT] & 0x80 ? 31 : 18); break;
1948 case VK_F8: code = (keystate[VK_SHIFT] & 0x80 ? 32 : 19); break;
1949 case VK_F9: code = (keystate[VK_SHIFT] & 0x80 ? 33 : 20); break;
1950 case VK_F10: code = (keystate[VK_SHIFT] & 0x80 ? 34 : 21); break;
1951 case VK_F11: code = 23; break;
1952 case VK_F12: code = 24; break;
1953 case VK_F13: code = 25; break;
1954 case VK_F14: code = 26; break;
1955 case VK_F15: code = 28; break;
1956 case VK_F16: code = 29; break;
1957 case VK_F17: code = 31; break;
1958 case VK_F18: code = 32; break;
1959 case VK_F19: code = 33; break;
1960 case VK_F20: code = 34; break;
1961 case VK_HOME: code = 1; break;
1962 case VK_INSERT: code = 2; break;
1963 case VK_DELETE: code = 3; break;
1964 case VK_END: code = 4; break;
1965 case VK_PRIOR: code = 5; break;
1966 case VK_NEXT: code = 6; break;
1968 if (cfg.funky_type == 1 && code >= 11 && code <= 15) {
1969 p += sprintf((char *)p, "\x1B[[%c", code + 'A' - 11);
1972 if (cfg.funky_type == 2 && code >= 11 && code <= 14) {
1973 p += sprintf((char *)p, "\x1BO%c", code + 'P' - 11);
1976 if (cfg.rxvt_homeend && (code == 1 || code == 4)) {
1977 p += sprintf((char *)p, code == 1 ? "\x1B[H" : "\x1BOw");
1981 p += sprintf((char *)p, "\x1B[%d~", code);
1986 * Now the remaining keys (arrows and Keypad 5. Keypad 5 for
1987 * some reason seems to send VK_CLEAR to Windows...).
1992 case VK_UP: xkey = 'A'; break;
1993 case VK_DOWN: xkey = 'B'; break;
1994 case VK_RIGHT: xkey = 'C'; break;
1995 case VK_LEFT: xkey = 'D'; break;
1996 case VK_CLEAR: xkey = 'G'; break;
2001 p += sprintf((char *)p, "\x1B%c", xkey);
2002 else if (app_cursor_keys)
2003 p += sprintf((char *)p, "\x1BO%c", xkey);
2005 p += sprintf((char *)p, "\x1B[%c", xkey);
2011 /* Okay we've done everything interesting; let windows deal with
2012 * the boring stuff */
2014 BOOL capsOn=keystate[VK_CAPITAL] !=0;
2016 /* helg: clear CAPS LOCK state if caps lock switches to cyrillic */
2017 if(cfg.xlat_capslockcyr)
2018 keystate[VK_CAPITAL] = 0;
2020 r = ToAscii (wParam, scan, keystate, keys, 0);
2026 unsigned char ch = (unsigned char)keys[i];
2028 if (compose_state==2 && (ch&0x80) == 0 && ch>' ') {
2033 if (compose_state==3 && (ch&0x80) == 0 && ch>' ') {
2037 if ((nc=check_compose(compose_char,ch)) == -1)
2042 *p++ = xlat_kbd2tty((unsigned char)nc);
2048 if( left_alt && key_down ) *p++ = '\033';
2054 ch = xlat_latkbd2win(ch);
2055 *p++ = xlat_kbd2tty(ch);
2059 /* This is so the ALT-Numpad and dead keys work correctly. */
2066 /* This stops ALT press-release doing a 'COMMAND MENU' function */
2068 if (message == WM_SYSKEYUP && wParam == VK_MENU)
2070 keystate[VK_MENU] = 0;
2078 void set_title (char *title) {
2079 sfree (window_name);
2080 window_name = smalloc(1+strlen(title));
2081 strcpy (window_name, title);
2082 if (cfg.win_name_always || !IsIconic(hwnd))
2083 SetWindowText (hwnd, title);
2086 void set_icon (char *title) {
2088 icon_name = smalloc(1+strlen(title));
2089 strcpy (icon_name, title);
2090 if (!cfg.win_name_always && IsIconic(hwnd))
2091 SetWindowText (hwnd, title);
2094 void set_sbar (int total, int start, int page) {
2097 if (!cfg.scrollbar) return;
2099 si.cbSize = sizeof(si);
2100 si.fMask = SIF_ALL | SIF_DISABLENOSCROLL;
2102 si.nMax = total - 1;
2106 SetScrollInfo (hwnd, SB_VERT, &si, TRUE);
2109 Context get_ctx(void) {
2114 SelectPalette (hdc, pal, FALSE);
2120 void free_ctx (Context ctx) {
2121 SelectPalette (ctx, GetStockObject (DEFAULT_PALETTE), FALSE);
2122 ReleaseDC (hwnd, ctx);
2125 static void real_palette_set (int n, int r, int g, int b) {
2127 logpal->palPalEntry[n].peRed = r;
2128 logpal->palPalEntry[n].peGreen = g;
2129 logpal->palPalEntry[n].peBlue = b;
2130 logpal->palPalEntry[n].peFlags = PC_NOCOLLAPSE;
2131 colours[n] = PALETTERGB(r, g, b);
2132 SetPaletteEntries (pal, 0, NCOLOURS, logpal->palPalEntry);
2134 colours[n] = RGB(r, g, b);
2137 void palette_set (int n, int r, int g, int b) {
2138 static const int first[21] = {
2139 0, 2, 4, 6, 8, 10, 12, 14,
2140 1, 3, 5, 7, 9, 11, 13, 15,
2143 real_palette_set (first[n], r, g, b);
2145 real_palette_set (first[n]+1, r, g, b);
2147 HDC hdc = get_ctx();
2148 UnrealizeObject (pal);
2149 RealizePalette (hdc);
2154 void palette_reset (void) {
2157 for (i = 0; i < NCOLOURS; i++) {
2159 logpal->palPalEntry[i].peRed = defpal[i].rgbtRed;
2160 logpal->palPalEntry[i].peGreen = defpal[i].rgbtGreen;
2161 logpal->palPalEntry[i].peBlue = defpal[i].rgbtBlue;
2162 logpal->palPalEntry[i].peFlags = 0;
2163 colours[i] = PALETTERGB(defpal[i].rgbtRed,
2164 defpal[i].rgbtGreen,
2165 defpal[i].rgbtBlue);
2167 colours[i] = RGB(defpal[i].rgbtRed,
2168 defpal[i].rgbtGreen,
2169 defpal[i].rgbtBlue);
2174 SetPaletteEntries (pal, 0, NCOLOURS, logpal->palPalEntry);
2176 RealizePalette (hdc);
2181 void write_clip (void *data, int len) {
2185 clipdata = GlobalAlloc (GMEM_DDESHARE | GMEM_MOVEABLE, len + 1);
2188 lock = GlobalLock (clipdata);
2191 memcpy (lock, data, len);
2192 ((unsigned char *) lock) [len] = 0;
2193 GlobalUnlock (clipdata);
2195 SendMessage (hwnd, WM_IGNORE_CLIP, TRUE, 0);
2196 if (OpenClipboard (hwnd)) {
2198 SetClipboardData (CF_TEXT, clipdata);
2201 GlobalFree (clipdata);
2202 SendMessage (hwnd, WM_IGNORE_CLIP, FALSE, 0);
2205 void get_clip (void **p, int *len) {
2206 static HGLOBAL clipdata = NULL;
2210 GlobalUnlock (clipdata);
2214 if (OpenClipboard (NULL)) {
2215 clipdata = GetClipboardData (CF_TEXT);
2218 *p = GlobalLock (clipdata);
2232 * Move `lines' lines from position `from' to position `to' in the
2235 void optimised_move (int to, int from, int lines) {
2239 min = (to < from ? to : from);
2240 max = to + from - min;
2242 r.left = 0; r.right = cols * font_width;
2243 r.top = min * font_height; r.bottom = (max+lines) * font_height;
2244 ScrollWindow (hwnd, 0, (to - from) * font_height, &r, &r);
2248 * Print a message box and perform a fatal exit.
2250 void fatalbox(char *fmt, ...) {
2255 vsprintf(stuff, fmt, ap);
2257 MessageBox(hwnd, stuff, "PuTTY Fatal Error", MB_ICONERROR | MB_OK);
2264 void beep(int errorbeep) {
2265 static long last_beep = 0;
2266 long now, beep_diff;
2268 now = GetTickCount();
2269 beep_diff = now-last_beep;
2271 /* Make sure we only respond to one beep per packet or so */
2272 if (beep_diff>=0 && beep_diff<50)
2276 MessageBeep(MB_ICONHAND);
2280 last_beep = GetTickCount();