16 #define PUTTY_DO_GLOBALS /* actually _define_ globals */
22 #define IDM_SHOWLOG 0x0010
23 #define IDM_NEWSESS 0x0020
24 #define IDM_DUPSESS 0x0030
25 #define IDM_RECONF 0x0040
26 #define IDM_CLRSB 0x0050
27 #define IDM_RESET 0x0060
28 #define IDM_TEL_AYT 0x0070
29 #define IDM_TEL_BRK 0x0080
30 #define IDM_TEL_SYNCH 0x0090
31 #define IDM_TEL_EC 0x00a0
32 #define IDM_TEL_EL 0x00b0
33 #define IDM_TEL_GA 0x00c0
34 #define IDM_TEL_NOP 0x00d0
35 #define IDM_TEL_ABORT 0x00e0
36 #define IDM_TEL_AO 0x00f0
37 #define IDM_TEL_IP 0x0100
38 #define IDM_TEL_SUSP 0x0110
39 #define IDM_TEL_EOR 0x0120
40 #define IDM_TEL_EOF 0x0130
41 #define IDM_ABOUT 0x0140
42 #define IDM_SAVEDSESS 0x0150
43 #define IDM_COPYALL 0x0160
45 #define IDM_SAVED_MIN 0x1000
46 #define IDM_SAVED_MAX 0x2000
48 #define WM_IGNORE_SIZE (WM_XUSER + 1)
49 #define WM_IGNORE_CLIP (WM_XUSER + 2)
51 /* Needed for Chinese support and apparently not always defined. */
53 #define VK_PROCESSKEY 0xE5
56 static LRESULT CALLBACK WndProc (HWND, UINT, WPARAM, LPARAM);
57 static int TranslateKey(UINT message, WPARAM wParam, LPARAM lParam, unsigned char *output);
58 static void cfgtopalette(void);
59 static void init_palette(void);
60 static void init_fonts(int);
62 static int extra_width, extra_height;
64 static int pending_netevent = 0;
65 static WPARAM pend_netevent_wParam = 0;
66 static LPARAM pend_netevent_lParam = 0;
67 static void enact_pending_netevent(void);
69 static time_t last_movement = 0;
73 #define FONT_UNDERLINE 2
74 #define FONT_BOLDUND 3
76 #define FONT_OEMBOLD 5
77 #define FONT_OEMBOLDUND 6
79 static HFONT fonts[8];
80 static int font_needs_hand_underlining;
82 BOLD_COLOURS, BOLD_SHADOW, BOLD_FONT
90 static COLORREF colours[NCOLOURS];
92 static LPLOGPALETTE logpal;
93 static RGBTRIPLE defpal[NCOLOURS];
97 static HBITMAP caretbm;
99 static int dbltime, lasttime, lastact;
100 static Mouse_Button lastbtn;
102 static char *window_name, *icon_name;
104 static int compose_state = 0;
106 /* Dummy routine, only required in plink. */
107 void ldisc_update(int echo, int edit) {}
109 int WINAPI WinMain(HINSTANCE inst, HINSTANCE prev, LPSTR cmdline, int show) {
110 static char appname[] = "PuTTY";
115 int guess_width, guess_height;
118 flags = FLAG_VERBOSE | FLAG_INTERACTIVE;
120 winsock_ver = MAKEWORD(1, 1);
121 if (WSAStartup(winsock_ver, &wsadata)) {
122 MessageBox(NULL, "Unable to initialise WinSock", "WinSock Error",
123 MB_OK | MB_ICONEXCLAMATION);
126 if (LOBYTE(wsadata.wVersion) != 1 || HIBYTE(wsadata.wVersion) != 1) {
127 MessageBox(NULL, "WinSock version is incompatible with 1.1",
128 "WinSock Error", MB_OK | MB_ICONEXCLAMATION);
132 /* WISHLIST: maybe allow config tweaking even if winsock not present? */
135 InitCommonControls();
137 /* Ensure a Maximize setting in Explorer doesn't maximise the
142 * Process the command line.
147 default_protocol = DEFAULT_PROTOCOL;
148 default_port = DEFAULT_PORT;
149 cfg.logtype = LGTYP_NONE;
151 do_defaults(NULL, &cfg);
154 while (*p && isspace(*p)) p++;
157 * Process command line options first. Yes, this can be
158 * done better, and it will be as soon as I have the
162 char *q = p + strcspn(p, " \t");
165 tolower(p[0]) == 's' &&
166 tolower(p[1]) == 's' &&
167 tolower(p[2]) == 'h') {
168 default_protocol = cfg.protocol = PROT_SSH;
169 default_port = cfg.port = 22;
170 } else if (q == p + 7 &&
171 tolower(p[0]) == 'c' &&
172 tolower(p[1]) == 'l' &&
173 tolower(p[2]) == 'e' &&
174 tolower(p[3]) == 'a' &&
175 tolower(p[4]) == 'n' &&
176 tolower(p[5]) == 'u' &&
177 tolower(p[6]) == 'p') {
179 * `putty -cleanup'. Remove all registry entries
180 * associated with PuTTY, and also find and delete
181 * the random seed file.
184 "This procedure will remove ALL Registry\n"
185 "entries associated with PuTTY, and will\n"
186 "also remove the PuTTY random seed file.\n"
188 "THIS PROCESS WILL DESTROY YOUR SAVED\n"
189 "SESSIONS. Are you really sure you want\n"
192 MB_YESNO | MB_ICONWARNING) == IDYES) {
197 p = q + strspn(q, " \t");
201 * An initial @ means to activate a saved session.
205 while (i > 1 && isspace(p[i-1]))
208 do_defaults (p+1, &cfg);
209 if (!*cfg.host && !do_config()) {
213 } else if (*p == '&') {
215 * An initial & means we've been given a command line
216 * containing the hex value of a HANDLE for a file
217 * mapping object, which we must then extract as a
222 if (sscanf(p+1, "%p", &filemap) == 1 &&
223 (cp = MapViewOfFile(filemap, FILE_MAP_READ,
224 0, 0, sizeof(Config))) != NULL) {
227 CloseHandle(filemap);
228 } else if (!do_config()) {
235 * If the hostname starts with "telnet:", set the
236 * protocol to Telnet and process the string as a
239 if (!strncmp(q, "telnet:", 7)) {
243 if (q[0] == '/' && q[1] == '/')
245 cfg.protocol = PROT_TELNET;
247 while (*p && *p != ':' && *p != '/') p++;
255 strncpy (cfg.host, q, sizeof(cfg.host)-1);
256 cfg.host[sizeof(cfg.host)-1] = '\0';
258 while (*p && !isspace(*p)) p++;
261 strncpy (cfg.host, q, sizeof(cfg.host)-1);
262 cfg.host[sizeof(cfg.host)-1] = '\0';
263 while (*p && isspace(*p)) p++;
276 /* See if host is of the form user@host */
277 if (cfg.host[0] != '\0') {
278 char *atsign = strchr(cfg.host, '@');
279 /* Make sure we're not overflowing the user field */
281 if (atsign-cfg.host < sizeof cfg.username) {
282 strncpy (cfg.username, cfg.host, atsign-cfg.host);
283 cfg.username[atsign-cfg.host] = '\0';
285 memmove(cfg.host, atsign+1, 1+strlen(atsign+1));
291 * Select protocol. This is farmed out into a table in a
292 * separate file to enable an ssh-free variant.
297 for (i = 0; backends[i].backend != NULL; i++)
298 if (backends[i].protocol == cfg.protocol) {
299 back = backends[i].backend;
303 MessageBox(NULL, "Unsupported protocol number found",
304 "PuTTY Internal Error", MB_OK | MB_ICONEXCLAMATION);
310 /* Check for invalid Port number (i.e. zero) */
312 MessageBox(NULL, "Invalid Port Number",
313 "PuTTY Internal Error", MB_OK |MB_ICONEXCLAMATION);
320 wndclass.lpfnWndProc = WndProc;
321 wndclass.cbClsExtra = 0;
322 wndclass.cbWndExtra = 0;
323 wndclass.hInstance = inst;
324 wndclass.hIcon = LoadIcon (inst,
325 MAKEINTRESOURCE(IDI_MAINICON));
326 wndclass.hCursor = LoadCursor (NULL, IDC_IBEAM);
327 wndclass.hbrBackground = GetStockObject (BLACK_BRUSH);
328 wndclass.lpszMenuName = NULL;
329 wndclass.lpszClassName = appname;
331 RegisterClass (&wndclass);
336 savelines = cfg.savelines;
342 * Guess some defaults for the window size. This all gets
343 * updated later, so we don't really care too much. However, we
344 * do want the font width/height guesses to correspond to a
345 * large font rather than a small one...
352 term_size (cfg.height, cfg.width, cfg.savelines);
353 guess_width = extra_width + font_width * cols;
354 guess_height = extra_height + font_height * rows;
357 HWND w = GetDesktopWindow();
358 GetWindowRect (w, &r);
359 if (guess_width > r.right - r.left)
360 guess_width = r.right - r.left;
361 if (guess_height > r.bottom - r.top)
362 guess_height = r.bottom - r.top;
366 int winmode = WS_OVERLAPPEDWINDOW|WS_VSCROLL;
368 if (!cfg.scrollbar) winmode &= ~(WS_VSCROLL);
369 if (cfg.locksize) winmode &= ~(WS_THICKFRAME|WS_MAXIMIZEBOX);
370 if (cfg.alwaysontop) exwinmode = WS_EX_TOPMOST;
371 hwnd = CreateWindowEx (exwinmode, appname, appname,
372 winmode, CW_USEDEFAULT, CW_USEDEFAULT,
373 guess_width, guess_height,
374 NULL, NULL, inst, NULL);
378 * Initialise the fonts, simultaneously correcting the guesses
379 * for font_{width,height}.
381 bold_mode = cfg.bold_colour ? BOLD_COLOURS : BOLD_FONT;
386 * Correct the guesses for extra_{width,height}.
390 GetWindowRect (hwnd, &wr);
391 GetClientRect (hwnd, &cr);
392 extra_width = wr.right - wr.left - cr.right + cr.left;
393 extra_height = wr.bottom - wr.top - cr.bottom + cr.top;
397 * Resize the window, now we know what size we _really_ want it
400 guess_width = extra_width + font_width * cols;
401 guess_height = extra_height + font_height * rows;
402 SendMessage (hwnd, WM_IGNORE_SIZE, 0, 0);
403 SetWindowPos (hwnd, NULL, 0, 0, guess_width, guess_height,
404 SWP_NOMOVE | SWP_NOREDRAW | SWP_NOZORDER);
407 * Set up a caret bitmap, with no content.
411 int size = (font_width+15)/16 * 2 * font_height;
412 bits = smalloc(size);
413 memset(bits, 0, size);
414 caretbm = CreateBitmap(font_width, font_height, 1, 1, bits);
417 CreateCaret(hwnd, caretbm, font_width, font_height);
420 * Initialise the scroll bar.
425 si.cbSize = sizeof(si);
426 si.fMask = SIF_ALL | SIF_DISABLENOSCROLL;
431 SetScrollInfo (hwnd, SB_VERT, &si, FALSE);
435 * Start up the telnet connection.
439 char msg[1024], *title;
442 error = back->init (cfg.host, cfg.port, &realhost);
444 sprintf(msg, "Unable to open connection:\n%s", error);
445 MessageBox(NULL, msg, "PuTTY Error", MB_ICONERROR | MB_OK);
448 window_name = icon_name = NULL;
450 title = cfg.wintitle;
452 sprintf(msg, "%s - PuTTY", realhost);
459 session_closed = FALSE;
462 * Set up the input and output buffers.
465 outbuf_reap = outbuf_head = 0;
468 * Prepare the mouse handler.
470 lastact = MA_NOTHING;
471 lastbtn = MB_NOTHING;
472 dbltime = GetDoubleClickTime();
475 * Set up the session-control options on the system menu.
478 HMENU m = GetSystemMenu (hwnd, FALSE);
482 AppendMenu (m, MF_SEPARATOR, 0, 0);
483 if (cfg.protocol == PROT_TELNET) {
485 AppendMenu (p, MF_ENABLED, IDM_TEL_AYT, "Are You There");
486 AppendMenu (p, MF_ENABLED, IDM_TEL_BRK, "Break");
487 AppendMenu (p, MF_ENABLED, IDM_TEL_SYNCH, "Synch");
488 AppendMenu (p, MF_SEPARATOR, 0, 0);
489 AppendMenu (p, MF_ENABLED, IDM_TEL_EC, "Erase Character");
490 AppendMenu (p, MF_ENABLED, IDM_TEL_EL, "Erase Line");
491 AppendMenu (p, MF_ENABLED, IDM_TEL_GA, "Go Ahead");
492 AppendMenu (p, MF_ENABLED, IDM_TEL_NOP, "No Operation");
493 AppendMenu (p, MF_SEPARATOR, 0, 0);
494 AppendMenu (p, MF_ENABLED, IDM_TEL_ABORT, "Abort Process");
495 AppendMenu (p, MF_ENABLED, IDM_TEL_AO, "Abort Output");
496 AppendMenu (p, MF_ENABLED, IDM_TEL_IP, "Interrupt Process");
497 AppendMenu (p, MF_ENABLED, IDM_TEL_SUSP, "Suspend Process");
498 AppendMenu (p, MF_SEPARATOR, 0, 0);
499 AppendMenu (p, MF_ENABLED, IDM_TEL_EOR, "End Of Record");
500 AppendMenu (p, MF_ENABLED, IDM_TEL_EOF, "End Of File");
501 AppendMenu (m, MF_POPUP | MF_ENABLED, (UINT) p, "Telnet Command");
502 AppendMenu (m, MF_SEPARATOR, 0, 0);
504 AppendMenu (m, MF_ENABLED, IDM_SHOWLOG, "&Event Log");
505 AppendMenu (m, MF_SEPARATOR, 0, 0);
506 AppendMenu (m, MF_ENABLED, IDM_NEWSESS, "Ne&w Session...");
507 AppendMenu (m, MF_ENABLED, IDM_DUPSESS, "&Duplicate Session");
510 for (i = 1 ; i < ((nsessions < 256) ? nsessions : 256) ; i++)
511 AppendMenu (s, MF_ENABLED, IDM_SAVED_MIN + (16 * i) , sessions[i]);
512 AppendMenu (m, MF_POPUP | MF_ENABLED, (UINT) s, "Sa&ved Sessions");
513 AppendMenu (m, MF_ENABLED, IDM_RECONF, "Chan&ge Settings...");
514 AppendMenu (m, MF_SEPARATOR, 0, 0);
515 AppendMenu (m, MF_ENABLED, IDM_COPYALL, "C&opy All to Clipboard");
516 AppendMenu (m, MF_ENABLED, IDM_CLRSB, "C&lear Scrollback");
517 AppendMenu (m, MF_ENABLED, IDM_RESET, "Rese&t Terminal");
518 AppendMenu (m, MF_SEPARATOR, 0, 0);
519 AppendMenu (m, MF_ENABLED, IDM_ABOUT, "&About PuTTY");
523 * Finally show the window!
525 ShowWindow (hwnd, show);
528 * Open the initial log file if there is one.
533 * Set the palette up.
539 has_focus = (GetForegroundWindow() == hwnd);
542 if (GetMessage (&msg, NULL, 0, 0) == 1)
544 int timer_id = 0, long_timer = 0;
546 while (msg.message != WM_QUIT) {
547 /* Sometimes DispatchMessage calls routines that use their own
548 * GetMessage loop, setup this timer so we get some control back.
550 * Also call term_update() from the timer so that if the host
551 * is sending data flat out we still do redraws.
553 if(timer_id && long_timer) {
554 KillTimer(hwnd, timer_id);
555 long_timer = timer_id = 0;
558 timer_id = SetTimer(hwnd, 1, 20, NULL);
559 if (!(IsWindow(logbox) && IsDialogMessage(logbox, &msg)))
560 DispatchMessage (&msg);
562 /* Make sure we blink everything that needs it. */
565 /* Send the paste buffer if there's anything to send */
568 /* If there's nothing new in the queue then we can do everything
569 * we've delayed, reading the socket, writing, and repainting
572 if (PeekMessage (&msg, NULL, 0, 0, PM_REMOVE))
575 if (pending_netevent) {
576 enact_pending_netevent();
578 /* Force the cursor blink on */
581 if (PeekMessage (&msg, NULL, 0, 0, PM_REMOVE))
585 /* Okay there is now nothing to do so we make sure the screen is
586 * completely up to date then tell windows to call us in a little
590 KillTimer(hwnd, timer_id);
599 timer_id = SetTimer(hwnd, 1, 59500, NULL);
601 timer_id = SetTimer(hwnd, 1, 100, NULL);
604 /* There's no point rescanning everything in the message queue
605 * so we do an apperently unneccesary wait here
608 if (GetMessage (&msg, NULL, 0, 0) != 1)
620 DeleteObject(fonts[i]);
627 if (cfg.protocol == PROT_SSH) {
638 * Set up, or shut down, an AsyncSelect. Called from winnet.c.
640 char *do_select(SOCKET skt, int startup) {
644 events = FD_READ | FD_WRITE | FD_OOB | FD_CLOSE;
649 return "do_select(): internal error (hwnd==NULL)";
650 if (WSAAsyncSelect (skt, hwnd, msg, events) == SOCKET_ERROR) {
651 switch (WSAGetLastError()) {
652 case WSAENETDOWN: return "Network is down";
653 default: return "WSAAsyncSelect(): unknown error";
660 * Print a message box and close the connection.
662 void connection_fatal(char *fmt, ...) {
667 vsprintf(stuff, fmt, ap);
669 MessageBox(hwnd, stuff, "PuTTY Fatal Error", MB_ICONERROR | MB_OK);
670 if (cfg.close_on_exit == COE_ALWAYS)
673 session_closed = TRUE;
674 SetWindowText (hwnd, "PuTTY (inactive)");
679 * Actually do the job requested by a WM_NETEVENT
681 static void enact_pending_netevent(void) {
682 static int reentering = 0;
683 extern int select_result(WPARAM, LPARAM);
687 return; /* don't unpend the pending */
689 pending_netevent = FALSE;
692 ret = select_result (pend_netevent_wParam, pend_netevent_lParam);
695 if (ret == 0 && !session_closed) {
696 /* Abnormal exits will already have set session_closed and taken
697 * appropriate action. */
698 if (cfg.close_on_exit == COE_ALWAYS ||
699 cfg.close_on_exit == COE_NORMAL)
702 session_closed = TRUE;
703 SetWindowText (hwnd, "PuTTY (inactive)");
704 MessageBox(hwnd, "Connection closed by remote host",
705 "PuTTY", MB_OK | MB_ICONINFORMATION);
711 * Copy the colour palette from the configuration data into defpal.
712 * This is non-trivial because the colour indices are different.
714 static void cfgtopalette(void) {
716 static const int ww[] = {
717 6, 7, 8, 9, 10, 11, 12, 13,
718 14, 15, 16, 17, 18, 19, 20, 21,
719 0, 1, 2, 3, 4, 4, 5, 5
722 for (i=0; i<24; i++) {
724 defpal[i].rgbtRed = cfg.colours[w][0];
725 defpal[i].rgbtGreen = cfg.colours[w][1];
726 defpal[i].rgbtBlue = cfg.colours[w][2];
731 * Set up the colour palette.
733 static void init_palette(void) {
735 HDC hdc = GetDC (hwnd);
737 if (cfg.try_palette &&
738 GetDeviceCaps (hdc, RASTERCAPS) & RC_PALETTE) {
739 logpal = smalloc(sizeof(*logpal)
740 - sizeof(logpal->palPalEntry)
741 + NCOLOURS * sizeof(PALETTEENTRY));
742 logpal->palVersion = 0x300;
743 logpal->palNumEntries = NCOLOURS;
744 for (i = 0; i < NCOLOURS; i++) {
745 logpal->palPalEntry[i].peRed = defpal[i].rgbtRed;
746 logpal->palPalEntry[i].peGreen = defpal[i].rgbtGreen;
747 logpal->palPalEntry[i].peBlue = defpal[i].rgbtBlue;
748 logpal->palPalEntry[i].peFlags = PC_NOCOLLAPSE;
750 pal = CreatePalette (logpal);
752 SelectPalette (hdc, pal, FALSE);
753 RealizePalette (hdc);
754 SelectPalette (hdc, GetStockObject (DEFAULT_PALETTE),
758 ReleaseDC (hwnd, hdc);
761 for (i=0; i<NCOLOURS; i++)
762 colours[i] = PALETTERGB(defpal[i].rgbtRed,
766 for(i=0; i<NCOLOURS; i++)
767 colours[i] = RGB(defpal[i].rgbtRed,
773 * Initialise all the fonts we will need. There may be as many as
774 * eight or as few as one. We also:
776 * - check the font width and height, correcting our guesses if
779 * - verify that the bold font is the same width as the ordinary
780 * one, and engage shadow bolding if not.
782 * - verify that the underlined font is the same width as the
783 * ordinary one (manual underlining by means of line drawing can
784 * be done in a pinch).
786 static void init_fonts(int pick_width) {
791 int fw_dontcare, fw_bold;
800 if (cfg.fontisbold) {
801 fw_dontcare = FW_BOLD;
804 fw_dontcare = FW_DONTCARE;
810 font_height = cfg.fontheight;
811 font_width = pick_width;
814 fonts[i] = CreateFont (font_height, font_width, 0, 0, w, FALSE, u, FALSE, \
815 c, OUT_DEFAULT_PRECIS, \
816 CLIP_DEFAULT_PRECIS, DEFAULT_QUALITY, \
817 FIXED_PITCH | FF_DONTCARE, cfg.font)
819 if (cfg.vtmode != VT_OEMONLY) {
820 f(FONT_NORMAL, cfg.fontcharset, fw_dontcare, FALSE);
822 SelectObject (hdc, fonts[FONT_NORMAL]);
823 GetTextMetrics(hdc, &tm);
824 font_height = tm.tmHeight;
825 font_width = tm.tmAveCharWidth;
827 f(FONT_UNDERLINE, cfg.fontcharset, fw_dontcare, TRUE);
830 * Some fonts, e.g. 9-pt Courier, draw their underlines
831 * outside their character cell. We successfully prevent
832 * screen corruption by clipping the text output, but then
833 * we lose the underline completely. Here we try to work
834 * out whether this is such a font, and if it is, we set a
835 * flag that causes underlines to be drawn by hand.
837 * Having tried other more sophisticated approaches (such
838 * as examining the TEXTMETRIC structure or requesting the
839 * height of a string), I think we'll do this the brute
840 * force way: we create a small bitmap, draw an underlined
841 * space on it, and test to see whether any pixels are
842 * foreground-coloured. (Since we expect the underline to
843 * go all the way across the character cell, we only search
844 * down a single column of the bitmap, half way across.)
848 HBITMAP und_bm, und_oldbm;
852 und_dc = CreateCompatibleDC(hdc);
853 und_bm = CreateCompatibleBitmap(hdc, font_width, font_height);
854 und_oldbm = SelectObject(und_dc, und_bm);
855 SelectObject(und_dc, fonts[FONT_UNDERLINE]);
856 SetTextAlign(und_dc, TA_TOP | TA_LEFT | TA_NOUPDATECP);
857 SetTextColor (und_dc, RGB(255,255,255));
858 SetBkColor (und_dc, RGB(0,0,0));
859 SetBkMode (und_dc, OPAQUE);
860 ExtTextOut (und_dc, 0, 0, ETO_OPAQUE, NULL, " ", 1, NULL);
862 for (i = 0; i < font_height; i++) {
863 c = GetPixel(und_dc, font_width/2, i);
867 SelectObject(und_dc, und_oldbm);
868 DeleteObject(und_bm);
870 font_needs_hand_underlining = !gotit;
873 if (bold_mode == BOLD_FONT) {
874 f(FONT_BOLD, cfg.fontcharset, fw_bold, FALSE);
875 f(FONT_BOLDUND, cfg.fontcharset, fw_bold, TRUE);
878 if (cfg.vtmode == VT_OEMANSI) {
879 f(FONT_OEM, OEM_CHARSET, fw_dontcare, FALSE);
880 f(FONT_OEMUND, OEM_CHARSET, fw_dontcare, TRUE);
882 if (bold_mode == BOLD_FONT) {
883 f(FONT_OEMBOLD, OEM_CHARSET, fw_bold, FALSE);
884 f(FONT_OEMBOLDUND, OEM_CHARSET, fw_bold, TRUE);
890 f(FONT_OEM, cfg.fontcharset, fw_dontcare, FALSE);
892 SelectObject (hdc, fonts[FONT_OEM]);
893 GetTextMetrics(hdc, &tm);
894 font_height = tm.tmHeight;
895 font_width = tm.tmAveCharWidth;
897 f(FONT_OEMUND, cfg.fontcharset, fw_dontcare, TRUE);
899 if (bold_mode == BOLD_FONT) {
900 f(FONT_BOLD, cfg.fontcharset, fw_bold, FALSE);
901 f(FONT_BOLDUND, cfg.fontcharset, fw_bold, TRUE);
906 descent = tm.tmAscent + 1;
907 if (descent >= font_height)
908 descent = font_height - 1;
909 firstchar = tm.tmFirstChar;
911 for (i=0; i<8; i++) {
913 if (SelectObject (hdc, fonts[i]) &&
914 GetTextMetrics(hdc, &tm) )
915 fsize[i] = tm.tmAveCharWidth + 256 * tm.tmHeight;
921 ReleaseDC (hwnd, hdc);
923 /* ... This is wrong in OEM only mode */
924 if (fsize[FONT_UNDERLINE] != fsize[FONT_NORMAL] ||
925 (bold_mode == BOLD_FONT &&
926 fsize[FONT_BOLDUND] != fsize[FONT_BOLD])) {
928 DeleteObject (fonts[FONT_UNDERLINE]);
929 if (bold_mode == BOLD_FONT)
930 DeleteObject (fonts[FONT_BOLDUND]);
933 if (bold_mode == BOLD_FONT &&
934 fsize[FONT_BOLD] != fsize[FONT_NORMAL]) {
935 bold_mode = BOLD_SHADOW;
936 DeleteObject (fonts[FONT_BOLD]);
937 if (und_mode == UND_FONT)
938 DeleteObject (fonts[FONT_BOLDUND]);
942 /* With the fascist font painting it doesn't matter if the linedraw font
943 * isn't exactly the right size anymore so we don't have to check this.
945 if (cfg.vtmode == VT_OEMANSI && fsize[FONT_OEM] != fsize[FONT_NORMAL] ) {
946 if( cfg.fontcharset == OEM_CHARSET )
948 MessageBox(NULL, "The OEM and ANSI versions of this font are\n"
949 "different sizes. Using OEM-only mode instead",
950 "Font Size Mismatch", MB_ICONINFORMATION | MB_OK);
951 cfg.vtmode = VT_OEMONLY;
953 else if( firstchar < ' ' )
955 MessageBox(NULL, "The OEM and ANSI versions of this font are\n"
956 "different sizes. Using XTerm mode instead",
957 "Font Size Mismatch", MB_ICONINFORMATION | MB_OK);
958 cfg.vtmode = VT_XWINDOWS;
962 MessageBox(NULL, "The OEM and ANSI versions of this font are\n"
963 "different sizes. Using ISO8859-1 mode instead",
964 "Font Size Mismatch", MB_ICONINFORMATION | MB_OK);
965 cfg.vtmode = VT_POORMAN;
970 DeleteObject (fonts[i]);
976 void request_resize (int w, int h, int refont) {
979 /* If the window is maximized supress resizing attempts */
980 if(IsZoomed(hwnd)) return;
983 /* Don't do this in OEMANSI, you may get disable messages */
984 if (refont && w != cols && (cols==80 || cols==132)
985 && cfg.vtmode != VT_OEMANSI)
987 if (refont && w != cols && (cols==80 || cols==132))
990 /* If font width too big for screen should we shrink the font more ? */
992 font_width = ((font_width*cols+w/2)/w);
999 DeleteObject(fonts[i]);
1001 bold_mode = cfg.bold_colour ? BOLD_COLOURS : BOLD_FONT;
1002 und_mode = UND_FONT;
1003 init_fonts(font_width);
1007 static int first_time = 1;
1013 /* Get the size of the screen */
1014 if (GetClientRect(GetDesktopWindow(),&ss))
1015 /* first_time = 0 */;
1016 else { first_time = 2; break; }
1018 /* Make sure the values are sane */
1019 width = (ss.right-ss.left-extra_width ) / font_width;
1020 height = (ss.bottom-ss.top-extra_height ) / font_height;
1022 if (w>width) w=width;
1023 if (h>height) h=height;
1029 width = extra_width + font_width * w;
1030 height = extra_height + font_height * h;
1032 SetWindowPos (hwnd, NULL, 0, 0, width, height,
1033 SWP_NOACTIVATE | SWP_NOCOPYBITS |
1034 SWP_NOMOVE | SWP_NOZORDER);
1037 static void click (Mouse_Button b, int x, int y) {
1038 int thistime = GetMessageTime();
1040 if (lastbtn == b && thistime - lasttime < dbltime) {
1041 lastact = (lastact == MA_CLICK ? MA_2CLK :
1042 lastact == MA_2CLK ? MA_3CLK :
1043 lastact == MA_3CLK ? MA_CLICK : MA_NOTHING);
1048 if (lastact != MA_NOTHING)
1049 term_mouse (b, lastact, x, y);
1050 lasttime = thistime;
1053 static void show_mouseptr(int show) {
1054 static int cursor_visible = 1;
1055 if (!cfg.hide_mouseptr) /* override if this feature disabled */
1057 if (cursor_visible && !show)
1059 else if (!cursor_visible && show)
1061 cursor_visible = show;
1064 static LRESULT CALLBACK WndProc (HWND hwnd, UINT message,
1065 WPARAM wParam, LPARAM lParam) {
1067 static int ignore_size = FALSE;
1068 static int ignore_clip = FALSE;
1069 static int just_reconfigged = FALSE;
1070 static int resizing = FALSE;
1071 static int need_backend_resize = FALSE;
1075 if (pending_netevent)
1076 enact_pending_netevent();
1083 if (cfg.ping_interval > 0)
1087 if (now-last_movement > cfg.ping_interval)
1089 back->special(TS_PING);
1090 last_movement = now;
1098 if (!cfg.warn_on_close || session_closed ||
1099 MessageBox(hwnd, "Are you sure you want to close this session?",
1100 "PuTTY Exit Confirmation",
1101 MB_ICONWARNING | MB_OKCANCEL) == IDOK)
1102 DestroyWindow(hwnd);
1106 PostQuitMessage (0);
1109 switch (wParam & ~0xF) { /* low 4 bits reserved to Windows */
1121 PROCESS_INFORMATION pi;
1122 HANDLE filemap = NULL;
1124 if (wParam == IDM_DUPSESS) {
1126 * Allocate a file-mapping memory chunk for the
1129 SECURITY_ATTRIBUTES sa;
1132 sa.nLength = sizeof(sa);
1133 sa.lpSecurityDescriptor = NULL;
1134 sa.bInheritHandle = TRUE;
1135 filemap = CreateFileMapping((HANDLE)0xFFFFFFFF,
1142 p = (Config *)MapViewOfFile(filemap,
1144 0, 0, sizeof(Config));
1146 *p = cfg; /* structure copy */
1150 sprintf(c, "putty &%p", filemap);
1152 } else if (wParam == IDM_SAVEDSESS) {
1153 char *session = sessions[(lParam - IDM_SAVED_MIN) / 16];
1154 cl = smalloc(16 + strlen(session)); /* 8, but play safe */
1156 cl = NULL; /* not a very important failure mode */
1158 sprintf(cl, "putty @%s", session);
1164 GetModuleFileName (NULL, b, sizeof(b)-1);
1166 si.lpReserved = NULL;
1167 si.lpDesktop = NULL;
1171 si.lpReserved2 = NULL;
1172 CreateProcess (b, cl, NULL, NULL, TRUE,
1173 NORMAL_PRIORITY_CLASS, NULL, NULL, &si, &pi);
1176 CloseHandle(filemap);
1183 int prev_alwaysontop = cfg.alwaysontop;
1184 char oldlogfile[FILENAME_MAX];
1186 int need_setwpos = FALSE;
1187 int old_fwidth, old_fheight;
1189 strcpy(oldlogfile, cfg.logfilename);
1190 oldlogtype = cfg.logtype;
1193 old_fwidth = font_width;
1194 old_fheight = font_height;
1195 GetWindowText(hwnd, cfg.wintitle, sizeof(cfg.wintitle));
1197 if (!do_reconfig(hwnd))
1200 if (strcmp(oldlogfile, cfg.logfilename) ||
1201 oldlogtype != cfg.logtype) {
1202 logfclose(); /* reset logging */
1206 just_reconfigged = TRUE;
1211 DeleteObject(fonts[i]);
1213 bold_mode = cfg.bold_colour ? BOLD_COLOURS : BOLD_FONT;
1214 und_mode = UND_FONT;
1218 * Flush the line discipline's edit buffer in the
1219 * case where local editing has just been disabled.
1221 ldisc_send(NULL, 0);
1229 /* Enable or disable the scroll bar, etc */
1231 LONG nflg, flag = GetWindowLong(hwnd, GWL_STYLE);
1232 LONG nexflag, exflag = GetWindowLong(hwnd, GWL_EXSTYLE);
1235 if (cfg.alwaysontop != prev_alwaysontop) {
1236 if (cfg.alwaysontop) {
1237 nexflag = WS_EX_TOPMOST;
1238 SetWindowPos(hwnd, HWND_TOPMOST, 0, 0, 0, 0,
1239 SWP_NOMOVE | SWP_NOSIZE);
1242 SetWindowPos(hwnd, HWND_NOTOPMOST, 0, 0, 0, 0,
1243 SWP_NOMOVE | SWP_NOSIZE);
1248 if (cfg.scrollbar) nflg |= WS_VSCROLL;
1249 else nflg &= ~WS_VSCROLL;
1251 nflg &= ~(WS_THICKFRAME|WS_MAXIMIZEBOX);
1253 nflg |= (WS_THICKFRAME|WS_MAXIMIZEBOX);
1255 if (nflg != flag || nexflag != exflag)
1260 SetWindowLong(hwnd, GWL_STYLE, nflg);
1261 if (nexflag != exflag)
1262 SetWindowLong(hwnd, GWL_EXSTYLE, nexflag);
1264 SendMessage (hwnd, WM_IGNORE_SIZE, 0, 0);
1266 SetWindowPos(hwnd, NULL, 0,0,0,0,
1267 SWP_NOACTIVATE|SWP_NOCOPYBITS|
1268 SWP_NOMOVE|SWP_NOSIZE|SWP_NOZORDER|
1271 GetWindowRect (hwnd, &wr);
1272 GetClientRect (hwnd, &cr);
1273 extra_width = wr.right - wr.left - cr.right + cr.left;
1274 extra_height = wr.bottom - wr.top - cr.bottom + cr.top;
1278 if (cfg.height != rows ||
1279 cfg.width != cols ||
1280 old_fwidth != font_width ||
1281 old_fheight != font_height ||
1282 cfg.savelines != savelines)
1283 need_setwpos = TRUE;
1284 term_size(cfg.height, cfg.width, cfg.savelines);
1285 InvalidateRect(hwnd, NULL, TRUE);
1288 SetWindowPos (hwnd, NULL, 0, 0,
1289 extra_width + font_width * cfg.width,
1290 extra_height + font_height * cfg.height,
1291 SWP_NOACTIVATE | SWP_NOCOPYBITS |
1292 SWP_NOMOVE | SWP_NOZORDER);
1294 set_title(cfg.wintitle);
1295 if (IsIconic(hwnd)) {
1296 SetWindowText (hwnd,
1297 cfg.win_name_always ? window_name : icon_name);
1310 case IDM_TEL_AYT: back->special (TS_AYT); break;
1311 case IDM_TEL_BRK: back->special (TS_BRK); break;
1312 case IDM_TEL_SYNCH: back->special (TS_SYNCH); break;
1313 case IDM_TEL_EC: back->special (TS_EC); break;
1314 case IDM_TEL_EL: back->special (TS_EL); break;
1315 case IDM_TEL_GA: back->special (TS_GA); break;
1316 case IDM_TEL_NOP: back->special (TS_NOP); break;
1317 case IDM_TEL_ABORT: back->special (TS_ABORT); break;
1318 case IDM_TEL_AO: back->special (TS_AO); break;
1319 case IDM_TEL_IP: back->special (TS_IP); break;
1320 case IDM_TEL_SUSP: back->special (TS_SUSP); break;
1321 case IDM_TEL_EOR: back->special (TS_EOR); break;
1322 case IDM_TEL_EOF: back->special (TS_EOF); break;
1327 if (wParam >= IDM_SAVED_MIN && wParam <= IDM_SAVED_MAX) {
1328 SendMessage(hwnd, WM_SYSCOMMAND, IDM_SAVEDSESS, wParam);
1333 #define X_POS(l) ((int)(short)LOWORD(l))
1334 #define Y_POS(l) ((int)(short)HIWORD(l))
1336 #define TO_CHR_X(x) (((x)<0 ? (x)-font_width+1 : (x)) / font_width)
1337 #define TO_CHR_Y(y) (((y)<0 ? (y)-font_height+1: (y)) / font_height)
1339 case WM_LBUTTONDOWN:
1341 click (MB_SELECT, TO_CHR_X(X_POS(lParam)),
1342 TO_CHR_Y(Y_POS(lParam)));
1347 term_mouse (MB_SELECT, MA_RELEASE, TO_CHR_X(X_POS(lParam)),
1348 TO_CHR_Y(Y_POS(lParam)));
1351 case WM_MBUTTONDOWN:
1354 click (cfg.mouse_is_xterm ? MB_PASTE : MB_EXTEND,
1355 TO_CHR_X(X_POS(lParam)),
1356 TO_CHR_Y(Y_POS(lParam)));
1360 term_mouse (cfg.mouse_is_xterm ? MB_PASTE : MB_EXTEND,
1361 MA_RELEASE, TO_CHR_X(X_POS(lParam)),
1362 TO_CHR_Y(Y_POS(lParam)));
1365 case WM_RBUTTONDOWN:
1368 click (cfg.mouse_is_xterm ? MB_EXTEND : MB_PASTE,
1369 TO_CHR_X(X_POS(lParam)),
1370 TO_CHR_Y(Y_POS(lParam)));
1374 term_mouse (cfg.mouse_is_xterm ? MB_EXTEND : MB_PASTE,
1375 MA_RELEASE, TO_CHR_X(X_POS(lParam)),
1376 TO_CHR_Y(Y_POS(lParam)));
1382 * Add the mouse position and message time to the random
1385 noise_ultralight(lParam);
1387 if (wParam & (MK_LBUTTON | MK_MBUTTON | MK_RBUTTON)) {
1389 if (wParam & MK_LBUTTON)
1391 else if (wParam & MK_MBUTTON)
1392 b = cfg.mouse_is_xterm ? MB_PASTE : MB_EXTEND;
1394 b = cfg.mouse_is_xterm ? MB_EXTEND : MB_PASTE;
1395 term_mouse (b, MA_DRAG, TO_CHR_X(X_POS(lParam)),
1396 TO_CHR_Y(Y_POS(lParam)));
1399 case WM_NCMOUSEMOVE:
1401 noise_ultralight(lParam);
1403 case WM_IGNORE_CLIP:
1404 ignore_clip = wParam; /* don't panic on DESTROYCLIPBOARD */
1406 case WM_DESTROYCLIPBOARD:
1409 ignore_clip = FALSE;
1415 hdc = BeginPaint (hwnd, &p);
1417 SelectPalette (hdc, pal, TRUE);
1418 RealizePalette (hdc);
1420 term_paint (hdc, p.rcPaint.left, p.rcPaint.top,
1421 p.rcPaint.right, p.rcPaint.bottom);
1422 SelectObject (hdc, GetStockObject(SYSTEM_FONT));
1423 SelectObject (hdc, GetStockObject(WHITE_PEN));
1424 EndPaint (hwnd, &p);
1429 /* Notice we can get multiple netevents, FD_READ, FD_WRITE etc
1430 * but the only one that's likely to try to overload us is FD_READ.
1431 * This means buffering just one is fine.
1433 if (pending_netevent)
1434 enact_pending_netevent();
1436 pending_netevent = TRUE;
1437 pend_netevent_wParam=wParam;
1438 pend_netevent_lParam=lParam;
1439 time(&last_movement);
1443 CreateCaret(hwnd, caretbm, font_width, font_height);
1456 case WM_IGNORE_SIZE:
1457 ignore_size = TRUE; /* don't panic on next WM_SIZE msg */
1459 case WM_ENTERSIZEMOVE:
1462 need_backend_resize = FALSE;
1464 case WM_EXITSIZEMOVE:
1467 if (need_backend_resize)
1472 int width, height, w, h, ew, eh;
1473 LPRECT r = (LPRECT)lParam;
1475 width = r->right - r->left - extra_width;
1476 height = r->bottom - r->top - extra_height;
1477 w = (width + font_width/2) / font_width; if (w < 1) w = 1;
1478 h = (height + font_height/2) / font_height; if (h < 1) h = 1;
1479 UpdateSizeTip(hwnd, w, h);
1480 ew = width - w * font_width;
1481 eh = height - h * font_height;
1483 if (wParam == WMSZ_LEFT ||
1484 wParam == WMSZ_BOTTOMLEFT ||
1485 wParam == WMSZ_TOPLEFT)
1491 if (wParam == WMSZ_TOP ||
1492 wParam == WMSZ_TOPRIGHT ||
1493 wParam == WMSZ_TOPLEFT)
1503 /* break; (never reached) */
1505 if (wParam == SIZE_MINIMIZED) {
1506 SetWindowText (hwnd,
1507 cfg.win_name_always ? window_name : icon_name);
1510 if (wParam == SIZE_RESTORED || wParam == SIZE_MAXIMIZED)
1511 SetWindowText (hwnd, window_name);
1513 int width, height, w, h;
1514 #if 0 /* we have fixed this using WM_SIZING now */
1518 width = LOWORD(lParam);
1519 height = HIWORD(lParam);
1520 w = width / font_width; if (w < 1) w = 1;
1521 h = height / font_height; if (h < 1) h = 1;
1522 #if 0 /* we have fixed this using WM_SIZING now */
1523 ew = width - w * font_width;
1524 eh = height - h * font_height;
1525 if (ew != 0 || eh != 0) {
1527 GetWindowRect (hwnd, &r);
1528 SendMessage (hwnd, WM_IGNORE_SIZE, 0, 0);
1529 SetWindowPos (hwnd, NULL, 0, 0,
1530 r.right - r.left - ew, r.bottom - r.top - eh,
1531 SWP_NOACTIVATE | SWP_NOMOVE | SWP_NOZORDER);
1534 if (w != cols || h != rows || just_reconfigged) {
1536 term_size (h, w, cfg.savelines);
1538 * Don't call back->size in mid-resize. (To prevent
1539 * massive numbers of resize events getting sent
1540 * down the connection during an NT opaque drag.)
1545 need_backend_resize = TRUE;
1546 just_reconfigged = FALSE;
1549 ignore_size = FALSE;
1552 switch (LOWORD(wParam)) {
1553 case SB_BOTTOM: term_scroll(-1, 0); break;
1554 case SB_TOP: term_scroll(+1, 0); break;
1555 case SB_LINEDOWN: term_scroll (0, +1); break;
1556 case SB_LINEUP: term_scroll (0, -1); break;
1557 case SB_PAGEDOWN: term_scroll (0, +rows/2); break;
1558 case SB_PAGEUP: term_scroll (0, -rows/2); break;
1559 case SB_THUMBPOSITION: case SB_THUMBTRACK:
1560 term_scroll (1, HIWORD(wParam)); break;
1563 case WM_PALETTECHANGED:
1564 if ((HWND) wParam != hwnd && pal != NULL) {
1565 HDC hdc = get_ctx();
1567 if (RealizePalette (hdc) > 0)
1573 case WM_QUERYNEWPALETTE:
1575 HDC hdc = get_ctx();
1577 if (RealizePalette (hdc) > 0)
1589 * Add the scan code and keypress timing to the random
1592 noise_ultralight(lParam);
1595 * We don't do TranslateMessage since it disassociates the
1596 * resulting CHAR message from the KEYDOWN that sparked it,
1597 * which we occasionally don't want. Instead, we process
1598 * KEYDOWN, and call the Win32 translator functions so that
1599 * we get the translations under _our_ control.
1602 unsigned char buf[20];
1605 if (wParam==VK_PROCESSKEY) {
1608 m.message = WM_KEYDOWN;
1610 m.lParam = lParam & 0xdfff;
1611 TranslateMessage(&m);
1613 len = TranslateKey (message, wParam, lParam, buf);
1615 return DefWindowProc (hwnd, message, wParam, lParam);
1616 ldisc_send (buf, len);
1625 unsigned char buf[2];
1628 buf[0] = wParam >> 8;
1629 ldisc_send (buf, 2);
1634 * Nevertheless, we are prepared to deal with WM_CHAR
1635 * messages, should they crop up. So if someone wants to
1636 * post the things to us as part of a macro manoeuvre,
1637 * we're ready to cope.
1640 char c = xlat_kbd2tty((unsigned char)wParam);
1646 return DefWindowProc (hwnd, message, wParam, lParam);
1650 * Move the system caret. (We maintain one, even though it's
1651 * invisible, for the benefit of blind people: apparently some
1652 * helper software tracks the system caret, so we should arrange to
1655 void sys_cursor(int x, int y) {
1656 SetCaretPos(x * font_width, y * font_height);
1660 * Draw a line of text in the window, at given character
1661 * coordinates, in given attributes.
1663 * We are allowed to fiddle with the contents of `text'.
1665 void do_text (Context ctx, int x, int y, char *text, int len,
1666 unsigned long attr, int lattr) {
1668 int nfg, nbg, nfont;
1671 int force_manual_underline = 0;
1672 int fnt_width = font_width*(1+(lattr!=LATTR_NORM));
1673 static int *IpDx = 0, IpDxLEN = 0;;
1675 if (len>IpDxLEN || IpDx[0] != fnt_width) {
1679 IpDx = smalloc((len+16)*sizeof(int));
1682 for(i=0; i<IpDxLEN; i++)
1683 IpDx[i] = fnt_width;
1689 if ((attr & ATTR_ACTCURS) && cfg.cursor_type == 0) {
1690 attr &= (bold_mode == BOLD_COLOURS ? 0x300200 : 0x300300);
1691 attr ^= ATTR_CUR_XOR;
1695 if (cfg.vtmode == VT_OEMONLY)
1699 * Map high-half characters in order to approximate ISO using
1700 * OEM character set. No characters are missing if the OEM codepage
1703 if (nfont & FONT_OEM) {
1705 for (i=0; i<len; i++)
1706 if (text[i] >= '\xA0' && text[i] <= '\xFF') {
1708 /* This is CP850 ... perfect translation */
1709 static const char oemhighhalf[] =
1710 "\x20\xAD\xBD\x9C\xCF\xBE\xDD\xF5" /* A0-A7 */
1711 "\xF9\xB8\xA6\xAE\xAA\xF0\xA9\xEE" /* A8-AF */
1712 "\xF8\xF1\xFD\xFC\xEF\xE6\xF4\xFA" /* B0-B7 */
1713 "\xF7\xFB\xA7\xAF\xAC\xAB\xF3\xA8" /* B8-BF */
1714 "\xB7\xB5\xB6\xC7\x8E\x8F\x92\x80" /* C0-C7 */
1715 "\xD4\x90\xD2\xD3\xDE\xD6\xD7\xD8" /* C8-CF */
1716 "\xD1\xA5\xE3\xE0\xE2\xE5\x99\x9E" /* D0-D7 */
1717 "\x9D\xEB\xE9\xEA\x9A\xED\xE8\xE1" /* D8-DF */
1718 "\x85\xA0\x83\xC6\x84\x86\x91\x87" /* E0-E7 */
1719 "\x8A\x82\x88\x89\x8D\xA1\x8C\x8B" /* E8-EF */
1720 "\xD0\xA4\x95\xA2\x93\xE4\x94\xF6" /* F0-F7 */
1721 "\x9B\x97\xA3\x96\x81\xEC\xE7\x98" /* F8-FF */
1724 /* This is CP437 ... junk translation */
1725 static const unsigned char oemhighhalf[] = {
1726 0xff, 0xad, 0x9b, 0x9c, 0x6f, 0x9d, 0x7c, 0x15,
1727 0x22, 0x43, 0xa6, 0xae, 0xaa, 0x2d, 0x52, 0xc4,
1728 0xf8, 0xf1, 0xfd, 0x33, 0x27, 0xe6, 0x14, 0xfa,
1729 0x2c, 0x31, 0xa7, 0xaf, 0xac, 0xab, 0x2f, 0xa8,
1730 0x41, 0x41, 0x41, 0x41, 0x8e, 0x8f, 0x92, 0x80,
1731 0x45, 0x90, 0x45, 0x45, 0x49, 0x49, 0x49, 0x49,
1732 0x44, 0xa5, 0x4f, 0x4f, 0x4f, 0x4f, 0x99, 0x78,
1733 0xed, 0x55, 0x55, 0x55, 0x9a, 0x59, 0x50, 0xe1,
1734 0x85, 0xa0, 0x83, 0x61, 0x84, 0x86, 0x91, 0x87,
1735 0x8a, 0x82, 0x88, 0x89, 0x8d, 0xa1, 0x8c, 0x8b,
1736 0x0b, 0xa4, 0x95, 0xa2, 0x93, 0x6f, 0x94, 0xf6,
1737 0xed, 0x97, 0xa3, 0x96, 0x81, 0x79, 0x70, 0x98
1740 text[i] = oemhighhalf[(unsigned char)text[i] - 0xA0];
1744 if (attr & ATTR_LINEDRW) {
1747 static const char poorman[] =
1748 "*#****\xB0\xB1**+++++-----++++|****\xA3\xB7";
1751 static const char oemmap_437[] =
1752 "\x04\xB1****\xF8\xF1**\xD9\xBF\xDA\xC0\xC5"
1753 "\xC4\xC4\xC4\xC4\xC4\xC3\xB4\xC1\xC2\xB3\xF3\xF2\xE3*\x9C\xFA";
1756 static const char oemmap_850[] =
1757 "\x04\xB1****\xF8\xF1**\xD9\xBF\xDA\xC0\xC5"
1758 "\xC4\xC4\xC4\xC4\xC4\xC3\xB4\xC1\xC2\xB3****\x9C\xFA";
1760 /* Poor windows font ... eg: windows courier */
1761 static const char oemmap[] =
1762 "*\xB1****\xF8\xF1**\xD9\xBF\xDA\xC0\xC5"
1763 "\xC4\xC4\xC4\xC4\xC4\xC3\xB4\xC1\xC2\xB3****\x9C\xFA";
1766 * Line drawing mapping: map ` thru ~ (0x60 thru 0x7E) to
1767 * VT100 line drawing chars; everything else stays normal.
1769 * Actually '_' maps to space too, but that's done before.
1771 switch (cfg.vtmode) {
1773 for (i=0; i<len; i++)
1774 if (text[i] >= '\x60' && text[i] <= '\x7E')
1775 text[i] += '\x01' - '\x60';
1778 /* Make sure we actually have an OEM font */
1779 if (fonts[nfont|FONT_OEM]) {
1782 for (i=0; i<len; i++)
1783 if (text[i] >= '\x60' && text[i] <= '\x7E')
1784 text[i] = oemmap[(unsigned char)text[i] - 0x60];
1788 for (i=0; i<len; i++)
1789 if (text[i] >= '\x60' && text[i] <= '\x7E')
1790 text[i] = poorman[(unsigned char)text[i] - 0x60];
1795 nfg = 2 * ((attr & ATTR_FGMASK) >> ATTR_FGSHIFT);
1796 nbg = 2 * ((attr & ATTR_BGMASK) >> ATTR_BGSHIFT);
1797 if (bold_mode == BOLD_FONT && (attr & ATTR_BOLD))
1799 if (und_mode == UND_FONT && (attr & ATTR_UNDER))
1800 nfont |= FONT_UNDERLINE;
1803 if (nfont&FONT_UNDERLINE)
1804 force_manual_underline = 1;
1805 /* Don't do the same for manual bold, it could be bad news. */
1807 nfont &= ~(FONT_BOLD|FONT_UNDERLINE);
1809 if (font_needs_hand_underlining && (attr & ATTR_UNDER))
1810 force_manual_underline = 1;
1811 if (attr & ATTR_REVERSE) {
1812 t = nfg; nfg = nbg; nbg = t;
1814 if (bold_mode == BOLD_COLOURS && (attr & ATTR_BOLD))
1816 if (bold_mode == BOLD_COLOURS && (attr & ATTR_BLINK))
1820 SelectObject (hdc, fonts[nfont]);
1821 SetTextColor (hdc, fg);
1822 SetBkColor (hdc, bg);
1823 SetBkMode (hdc, OPAQUE);
1826 line_box.right = x+fnt_width*len;
1827 line_box.bottom = y+font_height;
1828 ExtTextOut (hdc, x, y, ETO_CLIPPED|ETO_OPAQUE, &line_box, text, len, IpDx);
1829 if (bold_mode == BOLD_SHADOW && (attr & ATTR_BOLD)) {
1830 SetBkMode (hdc, TRANSPARENT);
1832 /* GRR: This draws the character outside it's box and can leave
1833 * 'droppings' even with the clip box! I suppose I could loop it
1834 * one character at a time ... yuk.
1836 * Or ... I could do a test print with "W", and use +1 or -1 for this
1837 * shift depending on if the leftmost column is blank...
1839 ExtTextOut (hdc, x-1, y, ETO_CLIPPED, &line_box, text, len, IpDx);
1841 if (force_manual_underline ||
1842 (und_mode == UND_LINE && (attr & ATTR_UNDER))) {
1844 oldpen = SelectObject (hdc, CreatePen(PS_SOLID, 0, fg));
1845 MoveToEx (hdc, x, y+descent, NULL);
1846 LineTo (hdc, x+len*fnt_width, y+descent);
1847 oldpen = SelectObject (hdc, oldpen);
1848 DeleteObject (oldpen);
1850 if ((attr & ATTR_PASCURS) && cfg.cursor_type == 0) {
1853 pts[0].x = pts[1].x = pts[4].x = x;
1854 pts[2].x = pts[3].x = x+fnt_width-1;
1855 pts[0].y = pts[3].y = pts[4].y = y;
1856 pts[1].y = pts[2].y = y+font_height-1;
1857 oldpen = SelectObject (hdc, CreatePen(PS_SOLID, 0, colours[23]));
1858 Polyline (hdc, pts, 5);
1859 oldpen = SelectObject (hdc, oldpen);
1860 DeleteObject (oldpen);
1862 if ((attr & (ATTR_ACTCURS | ATTR_PASCURS)) && cfg.cursor_type != 0) {
1863 int startx, starty, dx, dy, length, i;
1864 if (cfg.cursor_type == 1) {
1865 startx = x; starty = y+descent;
1866 dx = 1; dy = 0; length = fnt_width;
1869 if (attr & ATTR_RIGHTCURS)
1870 xadjust = fnt_width-1;
1871 startx = x+xadjust; starty = y;
1872 dx = 0; dy = 1; length = font_height;
1874 if (attr & ATTR_ACTCURS) {
1876 oldpen = SelectObject (hdc, CreatePen(PS_SOLID, 0, colours[23]));
1877 MoveToEx (hdc, startx, starty, NULL);
1878 LineTo (hdc, startx+dx*length, starty+dy*length);
1879 oldpen = SelectObject (hdc, oldpen);
1880 DeleteObject (oldpen);
1882 for (i = 0; i < length; i++) {
1884 SetPixel(hdc, startx, starty, colours[23]);
1886 startx += dx; starty += dy;
1892 static int check_compose(int first, int second) {
1894 static char * composetbl[] = {
1895 "++#", "AA@", "(([", "//\\", "))]", "(-{", "-)}", "/^|", "!!¡", "C/¢",
1896 "C|¢", "L-£", "L=£", "XO¤", "X0¤", "Y-¥", "Y=¥", "||¦", "SO§", "S!§",
1897 "S0§", "\"\"¨", "CO©", "C0©", "A_ª", "<<«", ",-¬", "--", "RO®",
1898 "-^¯", "0^°", "+-±", "2^²", "3^³", "''´", "/Uµ", "P!¶", ".^·", ",,¸",
1899 "1^¹", "O_º", ">>»", "14¼", "12½", "34¾", "??¿", "`AÀ", "'AÁ", "^AÂ",
1900 "~AÃ", "\"AÄ", "*AÅ", "AEÆ", ",CÇ", "`EÈ", "'EÉ", "^EÊ", "\"EË",
1901 "`IÌ", "'IÍ", "^IÎ", "\"IÏ", "-DÐ", "~NÑ", "`OÒ", "'OÓ", "^OÔ",
1902 "~OÕ", "\"OÖ", "XX×", "/OØ", "`UÙ", "'UÚ", "^UÛ", "\"UÜ", "'YÝ",
1903 "HTÞ", "ssß", "`aà", "'aá", "^aâ", "~aã", "\"aä", "*aå", "aeæ", ",cç",
1904 "`eè", "'eé", "^eê", "\"eë", "`iì", "'ií", "^iî", "\"iï", "-dð", "~nñ",
1905 "`oò", "'oó", "^oô", "~oõ", "\"oö", ":-÷", "o/ø", "`uù", "'uú", "^uû",
1906 "\"uü", "'yý", "htþ", "\"yÿ",
1910 static int recurse = 0;
1913 for(c=composetbl; *c; c++) {
1914 if( (*c)[0] == first && (*c)[1] == second)
1916 return (*c)[2] & 0xFF;
1923 nc = check_compose(second, first);
1925 nc = check_compose(toupper(first), toupper(second));
1927 nc = check_compose(toupper(second), toupper(first));
1935 * Translate a WM_(SYS)?KEY(UP|DOWN) message into a string of ASCII
1936 * codes. Returns number of bytes used or zero to drop the message
1937 * or -1 to forward the message to windows.
1939 static int TranslateKey(UINT message, WPARAM wParam, LPARAM lParam,
1940 unsigned char *output) {
1942 int scan, left_alt = 0, key_down, shift_state;
1944 unsigned char * p = output;
1945 static int alt_state = 0;
1947 HKL kbd_layout = GetKeyboardLayout(0);
1949 static WORD keys[3];
1950 static int compose_char = 0;
1951 static WPARAM compose_key = 0;
1953 r = GetKeyboardState(keystate);
1954 if (!r) memset(keystate, 0, sizeof(keystate));
1958 { /* Tell us all about key events */
1959 static BYTE oldstate[256];
1960 static int first = 1;
1963 if(first) memcpy(oldstate, keystate, sizeof(oldstate));
1966 if ((HIWORD(lParam)&(KF_UP|KF_REPEAT))==KF_REPEAT) {
1968 } else if ((HIWORD(lParam)&KF_UP) && scan==(HIWORD(lParam) & 0xFF) ) {
1972 if (wParam >= VK_F1 && wParam <= VK_F20 )
1973 debug(("K_F%d", wParam+1-VK_F1));
1976 case VK_SHIFT: debug(("SHIFT")); break;
1977 case VK_CONTROL: debug(("CTRL")); break;
1978 case VK_MENU: debug(("ALT")); break;
1979 default: debug(("VK_%02x", wParam));
1981 if(message == WM_SYSKEYDOWN || message == WM_SYSKEYUP)
1983 debug((", S%02x", scan=(HIWORD(lParam) & 0xFF) ));
1985 ch = MapVirtualKeyEx(wParam, 2, kbd_layout);
1986 if (ch>=' ' && ch<='~') debug((", '%c'", ch));
1987 else if (ch) debug((", $%02x", ch));
1989 if (keys[0]) debug((", KB0=%02x", keys[0]));
1990 if (keys[1]) debug((", KB1=%02x", keys[1]));
1991 if (keys[2]) debug((", KB2=%02x", keys[2]));
1993 if ( (keystate[VK_SHIFT]&0x80)!=0) debug((", S"));
1994 if ( (keystate[VK_CONTROL]&0x80)!=0) debug((", C"));
1995 if ( (HIWORD(lParam)&KF_EXTENDED) ) debug((", E"));
1996 if ( (HIWORD(lParam)&KF_UP) ) debug((", U"));
1999 if ((HIWORD(lParam)&(KF_UP|KF_REPEAT))==KF_REPEAT)
2001 else if ( (HIWORD(lParam)&KF_UP) )
2002 oldstate[wParam&0xFF] ^= 0x80;
2004 oldstate[wParam&0xFF] ^= 0x81;
2006 for(ch=0; ch<256; ch++)
2007 if (oldstate[ch] != keystate[ch])
2008 debug((", M%02x=%02x", ch, keystate[ch]));
2010 memcpy(oldstate, keystate, sizeof(oldstate));
2014 if (wParam == VK_MENU && (HIWORD(lParam)&KF_EXTENDED)) {
2015 keystate[VK_RMENU] = keystate[VK_MENU];
2018 /* Note if AltGr was pressed and if it was used as a compose key */
2019 if (cfg.compose_key) {
2020 if (wParam == VK_MENU && (HIWORD(lParam)&KF_EXTENDED))
2022 if (!compose_state) compose_key = wParam;
2024 if (wParam == VK_APPS && !compose_state)
2025 compose_key = wParam;
2027 if (wParam == compose_key)
2029 if (compose_state == 0 && (HIWORD(lParam)&(KF_UP|KF_REPEAT))==0)
2031 else if (compose_state == 1 && (HIWORD(lParam)&KF_UP))
2036 else if (compose_state==1 && wParam != VK_CONTROL)
2042 /* Nastyness with NUMLock - Shift-NUMLock is left alone though */
2043 if ( (cfg.funky_type == 3 ||
2044 (cfg.funky_type <= 1 && app_keypad_keys && !cfg.no_applic_k))
2045 && wParam==VK_NUMLOCK && !(keystate[VK_SHIFT]&0x80)) {
2047 wParam = VK_EXECUTE;
2049 /* UnToggle NUMLock */
2050 if ((HIWORD(lParam)&(KF_UP|KF_REPEAT))==0)
2051 keystate[VK_NUMLOCK] ^= 1;
2054 /* And write back the 'adjusted' state */
2055 SetKeyboardState (keystate);
2058 /* Disable Auto repeat if required */
2059 if (repeat_off && (HIWORD(lParam)&(KF_UP|KF_REPEAT))==KF_REPEAT)
2062 if ((HIWORD(lParam)&KF_ALTDOWN) && (keystate[VK_RMENU]&0x80) == 0)
2065 key_down = ((HIWORD(lParam)&KF_UP)==0);
2067 /* Make sure Ctrl-ALT is not the same as AltGr for ToAscii */
2068 if (left_alt && (keystate[VK_CONTROL]&0x80))
2069 keystate[VK_MENU] = 0;
2071 scan = (HIWORD(lParam) & (KF_UP | KF_EXTENDED | 0xFF));
2072 shift_state = ((keystate[VK_SHIFT]&0x80)!=0)
2073 + ((keystate[VK_CONTROL]&0x80)!=0)*2;
2076 * Record that we pressed key so the scroll window can be reset, but
2077 * be careful to avoid Shift-UP/Down
2079 if( wParam != VK_SHIFT && wParam != VK_PRIOR && wParam != VK_NEXT ) {
2083 /* Make sure we're not pasting */
2084 if (key_down) term_nopaste();
2086 if (compose_state>1 && left_alt) compose_state = 0;
2088 /* Sanitize the number pad if not using a PC NumPad */
2089 if( left_alt || (app_keypad_keys && !cfg.no_applic_k
2090 && cfg.funky_type != 2)
2091 || cfg.funky_type == 3 || cfg.nethack_keypad || compose_state )
2093 if ((HIWORD(lParam)&KF_EXTENDED) == 0)
2098 case VK_INSERT: nParam = VK_NUMPAD0; break;
2099 case VK_END: nParam = VK_NUMPAD1; break;
2100 case VK_DOWN: nParam = VK_NUMPAD2; break;
2101 case VK_NEXT: nParam = VK_NUMPAD3; break;
2102 case VK_LEFT: nParam = VK_NUMPAD4; break;
2103 case VK_CLEAR: nParam = VK_NUMPAD5; break;
2104 case VK_RIGHT: nParam = VK_NUMPAD6; break;
2105 case VK_HOME: nParam = VK_NUMPAD7; break;
2106 case VK_UP: nParam = VK_NUMPAD8; break;
2107 case VK_PRIOR: nParam = VK_NUMPAD9; break;
2108 case VK_DELETE: nParam = VK_DECIMAL; break;
2112 if (keystate[VK_NUMLOCK]&1) shift_state |= 1;
2118 /* If a key is pressed and AltGr is not active */
2119 if (key_down && (keystate[VK_RMENU]&0x80) == 0 && !compose_state)
2121 /* Okay, prepare for most alts then ...*/
2122 if (left_alt) *p++ = '\033';
2124 /* Lets see if it's a pattern we know all about ... */
2125 if (wParam == VK_PRIOR && shift_state == 1) {
2126 SendMessage (hwnd, WM_VSCROLL, SB_PAGEUP, 0);
2129 if (wParam == VK_NEXT && shift_state == 1) {
2130 SendMessage (hwnd, WM_VSCROLL, SB_PAGEDOWN, 0);
2133 if (wParam == VK_INSERT && shift_state == 1) {
2134 term_mouse (MB_PASTE, MA_CLICK, 0, 0);
2135 term_mouse (MB_PASTE, MA_RELEASE, 0, 0);
2138 if (left_alt && wParam == VK_F4 && cfg.alt_f4) {
2141 if (left_alt && wParam == VK_SPACE && cfg.alt_space) {
2143 PostMessage(hwnd, WM_CHAR, ' ', 0);
2144 SendMessage (hwnd, WM_SYSCOMMAND, SC_KEYMENU, 0);
2147 /* Control-Numlock for app-keypad mode switch */
2148 if (wParam == VK_PAUSE && shift_state == 2) {
2149 app_keypad_keys ^= 1;
2153 /* Nethack keypad */
2154 if (cfg.nethack_keypad && !left_alt) {
2156 case VK_NUMPAD1: *p++ = shift_state ? 'B': 'b'; return p-output;
2157 case VK_NUMPAD2: *p++ = shift_state ? 'J': 'j'; return p-output;
2158 case VK_NUMPAD3: *p++ = shift_state ? 'N': 'n'; return p-output;
2159 case VK_NUMPAD4: *p++ = shift_state ? 'H': 'h'; return p-output;
2160 case VK_NUMPAD5: *p++ = shift_state ? '.': '.'; return p-output;
2161 case VK_NUMPAD6: *p++ = shift_state ? 'L': 'l'; return p-output;
2162 case VK_NUMPAD7: *p++ = shift_state ? 'Y': 'y'; return p-output;
2163 case VK_NUMPAD8: *p++ = shift_state ? 'K': 'k'; return p-output;
2164 case VK_NUMPAD9: *p++ = shift_state ? 'U': 'u'; return p-output;
2168 /* Application Keypad */
2172 if ( cfg.funky_type == 3 ||
2173 ( cfg.funky_type <= 1 &&
2174 app_keypad_keys && !cfg.no_applic_k)) switch(wParam) {
2175 case VK_EXECUTE: xkey = 'P'; break;
2176 case VK_DIVIDE: xkey = 'Q'; break;
2177 case VK_MULTIPLY:xkey = 'R'; break;
2178 case VK_SUBTRACT:xkey = 'S'; break;
2180 if(app_keypad_keys && !cfg.no_applic_k) switch(wParam) {
2181 case VK_NUMPAD0: xkey = 'p'; break;
2182 case VK_NUMPAD1: xkey = 'q'; break;
2183 case VK_NUMPAD2: xkey = 'r'; break;
2184 case VK_NUMPAD3: xkey = 's'; break;
2185 case VK_NUMPAD4: xkey = 't'; break;
2186 case VK_NUMPAD5: xkey = 'u'; break;
2187 case VK_NUMPAD6: xkey = 'v'; break;
2188 case VK_NUMPAD7: xkey = 'w'; break;
2189 case VK_NUMPAD8: xkey = 'x'; break;
2190 case VK_NUMPAD9: xkey = 'y'; break;
2192 case VK_DECIMAL: xkey = 'n'; break;
2193 case VK_ADD: if(cfg.funky_type==2) {
2194 if(shift_state) xkey = 'l';
2196 } else if(shift_state) xkey = 'm';
2200 case VK_DIVIDE: if(cfg.funky_type==2) xkey = 'o'; break;
2201 case VK_MULTIPLY:if(cfg.funky_type==2) xkey = 'j'; break;
2202 case VK_SUBTRACT:if(cfg.funky_type==2) xkey = 'm'; break;
2205 if (HIWORD(lParam)&KF_EXTENDED)
2213 if (xkey>='P' && xkey<='S')
2214 p += sprintf((char *)p, "\x1B%c", xkey);
2216 p += sprintf((char *)p, "\x1B?%c", xkey);
2219 p += sprintf((char *)p, "\x1BO%c", xkey);
2224 if (wParam == VK_BACK && shift_state == 0 ) /* Backspace */
2226 *p++ = (cfg.bksp_is_delete ? 0x7F : 0x08);
2229 if (wParam == VK_TAB && shift_state == 1 ) /* Shift tab */
2231 *p++ = 0x1B; *p++ = '['; *p++ = 'Z'; return p - output;
2233 if (wParam == VK_SPACE && shift_state == 2 ) /* Ctrl-Space */
2235 *p++ = 0; return p - output;
2237 if (wParam == VK_SPACE && shift_state == 3 ) /* Ctrl-Shift-Space */
2239 *p++ = 160; return p - output;
2241 if (wParam == VK_CANCEL && shift_state == 2 ) /* Ctrl-Break */
2243 *p++ = 3; return p - output;
2245 /* Control-2 to Control-8 are special */
2246 if (shift_state == 2 && wParam >= '2' && wParam <= '8')
2248 *p++ = "\000\033\034\035\036\037\177"[wParam-'2'];
2251 if (shift_state == 2 && wParam == 0xBD) {
2255 if (shift_state == 2 && wParam == 0xDF) {
2259 if (shift_state == 0 && wParam == VK_RETURN && cr_lf_return) {
2260 *p++ = '\r'; *p++ = '\n';
2265 * Next, all the keys that do tilde codes. (ESC '[' nn '~',
2266 * for integer decimal nn.)
2268 * We also deal with the weird ones here. Linux VCs replace F1
2269 * to F5 by ESC [ [ A to ESC [ [ E. rxvt doesn't do _that_, but
2270 * does replace Home and End (1~ and 4~) by ESC [ H and ESC O w
2275 case VK_F1: code = (keystate[VK_SHIFT] & 0x80 ? 23 : 11); break;
2276 case VK_F2: code = (keystate[VK_SHIFT] & 0x80 ? 24 : 12); break;
2277 case VK_F3: code = (keystate[VK_SHIFT] & 0x80 ? 25 : 13); break;
2278 case VK_F4: code = (keystate[VK_SHIFT] & 0x80 ? 26 : 14); break;
2279 case VK_F5: code = (keystate[VK_SHIFT] & 0x80 ? 28 : 15); break;
2280 case VK_F6: code = (keystate[VK_SHIFT] & 0x80 ? 29 : 17); break;
2281 case VK_F7: code = (keystate[VK_SHIFT] & 0x80 ? 31 : 18); break;
2282 case VK_F8: code = (keystate[VK_SHIFT] & 0x80 ? 32 : 19); break;
2283 case VK_F9: code = (keystate[VK_SHIFT] & 0x80 ? 33 : 20); break;
2284 case VK_F10: code = (keystate[VK_SHIFT] & 0x80 ? 34 : 21); break;
2285 case VK_F11: code = 23; break;
2286 case VK_F12: code = 24; break;
2287 case VK_F13: code = 25; break;
2288 case VK_F14: code = 26; break;
2289 case VK_F15: code = 28; break;
2290 case VK_F16: code = 29; break;
2291 case VK_F17: code = 31; break;
2292 case VK_F18: code = 32; break;
2293 case VK_F19: code = 33; break;
2294 case VK_F20: code = 34; break;
2295 case VK_HOME: code = 1; break;
2296 case VK_INSERT: code = 2; break;
2297 case VK_DELETE: code = 3; break;
2298 case VK_END: code = 4; break;
2299 case VK_PRIOR: code = 5; break;
2300 case VK_NEXT: code = 6; break;
2302 /* Reorder edit keys to physical order */
2303 if (cfg.funky_type == 3 && code <= 6 ) code = "\0\2\1\4\5\3\6"[code];
2305 if (cfg.funky_type == 1 && code >= 11 && code <= 15) {
2306 p += sprintf((char *)p, "\x1B[[%c", code + 'A' - 11);
2309 if (cfg.funky_type == 2 && code >= 11 && code <= 14) {
2311 p += sprintf((char *)p, "\x1B%c", code + 'P' - 11);
2313 p += sprintf((char *)p, "\x1BO%c", code + 'P' - 11);
2316 if (cfg.rxvt_homeend && (code == 1 || code == 4)) {
2317 p += sprintf((char *)p, code == 1 ? "\x1B[H" : "\x1BOw");
2321 p += sprintf((char *)p, "\x1B[%d~", code);
2326 * Now the remaining keys (arrows and Keypad 5. Keypad 5 for
2327 * some reason seems to send VK_CLEAR to Windows...).
2332 case VK_UP: xkey = 'A'; break;
2333 case VK_DOWN: xkey = 'B'; break;
2334 case VK_RIGHT: xkey = 'C'; break;
2335 case VK_LEFT: xkey = 'D'; break;
2336 case VK_CLEAR: xkey = 'G'; break;
2341 p += sprintf((char *)p, "\x1B%c", xkey);
2342 else if (app_cursor_keys && !cfg.no_applic_c)
2343 p += sprintf((char *)p, "\x1BO%c", xkey);
2345 p += sprintf((char *)p, "\x1B[%c", xkey);
2351 * Finally, deal with Return ourselves. (Win95 seems to
2352 * foul it up when Alt is pressed, for some reason.)
2354 if (wParam == VK_RETURN) /* Return */
2361 /* Okay we've done everything interesting; let windows deal with
2362 * the boring stuff */
2364 BOOL capsOn=keystate[VK_CAPITAL] !=0;
2366 /* helg: clear CAPS LOCK state if caps lock switches to cyrillic */
2367 if(cfg.xlat_capslockcyr)
2368 keystate[VK_CAPITAL] = 0;
2370 r = ToAsciiEx(wParam, scan, keystate, keys, 0, kbd_layout);
2376 unsigned char ch = (unsigned char)keys[i];
2378 if (compose_state==2 && (ch&0x80) == 0 && ch>' ') {
2383 if (compose_state==3 && (ch&0x80) == 0 && ch>' ') {
2387 if ((nc=check_compose(compose_char,ch)) == -1)
2389 MessageBeep(MB_ICONHAND);
2392 *p++ = xlat_kbd2tty((unsigned char)nc);
2398 if( left_alt && key_down ) *p++ = '\033';
2404 ch = xlat_latkbd2win(ch);
2405 *p++ = xlat_kbd2tty(ch);
2409 /* This is so the ALT-Numpad and dead keys work correctly. */
2416 /* ALT alone may or may not want to bring up the System menu */
2417 if (wParam == VK_MENU) {
2419 if (message == WM_SYSKEYDOWN)
2421 else if (message == WM_SYSKEYUP && alt_state)
2422 PostMessage(hwnd, WM_CHAR, ' ', 0);
2423 if (message == WM_SYSKEYUP)
2432 void set_title (char *title) {
2433 sfree (window_name);
2434 window_name = smalloc(1+strlen(title));
2435 strcpy (window_name, title);
2436 if (cfg.win_name_always || !IsIconic(hwnd))
2437 SetWindowText (hwnd, title);
2440 void set_icon (char *title) {
2442 icon_name = smalloc(1+strlen(title));
2443 strcpy (icon_name, title);
2444 if (!cfg.win_name_always && IsIconic(hwnd))
2445 SetWindowText (hwnd, title);
2448 void set_sbar (int total, int start, int page) {
2451 if (!cfg.scrollbar) return;
2453 si.cbSize = sizeof(si);
2454 si.fMask = SIF_ALL | SIF_DISABLENOSCROLL;
2456 si.nMax = total - 1;
2460 SetScrollInfo (hwnd, SB_VERT, &si, TRUE);
2463 Context get_ctx(void) {
2468 SelectPalette (hdc, pal, FALSE);
2474 void free_ctx (Context ctx) {
2475 SelectPalette (ctx, GetStockObject (DEFAULT_PALETTE), FALSE);
2476 ReleaseDC (hwnd, ctx);
2479 static void real_palette_set (int n, int r, int g, int b) {
2481 logpal->palPalEntry[n].peRed = r;
2482 logpal->palPalEntry[n].peGreen = g;
2483 logpal->palPalEntry[n].peBlue = b;
2484 logpal->palPalEntry[n].peFlags = PC_NOCOLLAPSE;
2485 colours[n] = PALETTERGB(r, g, b);
2486 SetPaletteEntries (pal, 0, NCOLOURS, logpal->palPalEntry);
2488 colours[n] = RGB(r, g, b);
2491 void palette_set (int n, int r, int g, int b) {
2492 static const int first[21] = {
2493 0, 2, 4, 6, 8, 10, 12, 14,
2494 1, 3, 5, 7, 9, 11, 13, 15,
2497 real_palette_set (first[n], r, g, b);
2499 real_palette_set (first[n]+1, r, g, b);
2501 HDC hdc = get_ctx();
2502 UnrealizeObject (pal);
2503 RealizePalette (hdc);
2508 void palette_reset (void) {
2511 for (i = 0; i < NCOLOURS; i++) {
2513 logpal->palPalEntry[i].peRed = defpal[i].rgbtRed;
2514 logpal->palPalEntry[i].peGreen = defpal[i].rgbtGreen;
2515 logpal->palPalEntry[i].peBlue = defpal[i].rgbtBlue;
2516 logpal->palPalEntry[i].peFlags = 0;
2517 colours[i] = PALETTERGB(defpal[i].rgbtRed,
2518 defpal[i].rgbtGreen,
2519 defpal[i].rgbtBlue);
2521 colours[i] = RGB(defpal[i].rgbtRed,
2522 defpal[i].rgbtGreen,
2523 defpal[i].rgbtBlue);
2528 SetPaletteEntries (pal, 0, NCOLOURS, logpal->palPalEntry);
2530 RealizePalette (hdc);
2535 void write_clip (void *data, int len, int must_deselect) {
2539 clipdata = GlobalAlloc (GMEM_DDESHARE | GMEM_MOVEABLE, len + 1);
2542 lock = GlobalLock (clipdata);
2545 memcpy (lock, data, len);
2546 ((unsigned char *) lock) [len] = 0;
2547 GlobalUnlock (clipdata);
2550 SendMessage (hwnd, WM_IGNORE_CLIP, TRUE, 0);
2552 if (OpenClipboard (hwnd)) {
2554 SetClipboardData (CF_TEXT, clipdata);
2557 GlobalFree (clipdata);
2560 SendMessage (hwnd, WM_IGNORE_CLIP, FALSE, 0);
2563 void get_clip (void **p, int *len) {
2564 static HGLOBAL clipdata = NULL;
2568 GlobalUnlock (clipdata);
2572 if (OpenClipboard (NULL)) {
2573 clipdata = GetClipboardData (CF_TEXT);
2576 *p = GlobalLock (clipdata);
2590 * Move `lines' lines from position `from' to position `to' in the
2593 void optimised_move (int to, int from, int lines) {
2597 min = (to < from ? to : from);
2598 max = to + from - min;
2600 r.left = 0; r.right = cols * font_width;
2601 r.top = min * font_height; r.bottom = (max+lines) * font_height;
2602 ScrollWindow (hwnd, 0, (to - from) * font_height, &r, &r);
2606 * Print a message box and perform a fatal exit.
2608 void fatalbox(char *fmt, ...) {
2613 vsprintf(stuff, fmt, ap);
2615 MessageBox(hwnd, stuff, "PuTTY Fatal Error", MB_ICONERROR | MB_OK);
2622 void beep(int errorbeep) {
2623 static long last_beep = 0;
2624 long now, beep_diff;
2626 now = GetTickCount();
2627 beep_diff = now-last_beep;
2629 /* Make sure we only respond to one beep per packet or so */
2630 if (beep_diff>=0 && beep_diff<50)
2634 MessageBeep(MB_ICONHAND);
2638 last_beep = GetTickCount();