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
44 #define IDM_SAVED_MIN 0x1000
45 #define IDM_SAVED_MAX 0x2000
47 #define WM_IGNORE_SIZE (WM_XUSER + 1)
48 #define WM_IGNORE_CLIP (WM_XUSER + 2)
50 /* Needed for Chinese support and apparently not always defined. */
52 #define VK_PROCESSKEY 0xE5
55 static LRESULT CALLBACK WndProc (HWND, UINT, WPARAM, LPARAM);
56 static int TranslateKey(UINT message, WPARAM wParam, LPARAM lParam, unsigned char *output);
57 static void cfgtopalette(void);
58 static void init_palette(void);
59 static void init_fonts(int);
61 static int extra_width, extra_height;
63 static int pending_netevent = 0;
64 static WPARAM pend_netevent_wParam = 0;
65 static LPARAM pend_netevent_lParam = 0;
66 static void enact_pending_netevent(void);
68 static time_t last_movement = 0;
72 #define FONT_UNDERLINE 2
73 #define FONT_BOLDUND 3
75 #define FONT_OEMBOLD 5
76 #define FONT_OEMBOLDUND 6
78 static HFONT fonts[8];
79 static int font_needs_hand_underlining;
81 BOLD_COLOURS, BOLD_SHADOW, BOLD_FONT
89 static COLORREF colours[NCOLOURS];
91 static LPLOGPALETTE logpal;
92 static RGBTRIPLE defpal[NCOLOURS];
96 static HBITMAP caretbm;
98 static int dbltime, lasttime, lastact;
99 static Mouse_Button lastbtn;
101 static char *window_name, *icon_name;
103 static Ldisc *real_ldisc;
105 void begin_session(void) {
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;
150 do_defaults(NULL, &cfg);
153 while (*p && isspace(*p)) p++;
156 * Process command line options first. Yes, this can be
157 * done better, and it will be as soon as I have the
161 char *q = p + strcspn(p, " \t");
164 tolower(p[0]) == 's' &&
165 tolower(p[1]) == 's' &&
166 tolower(p[2]) == 'h') {
167 default_protocol = cfg.protocol = PROT_SSH;
168 default_port = cfg.port = 22;
169 } else if (q == p + 3 &&
170 tolower(p[0]) == 'l' &&
171 tolower(p[1]) == 'o' &&
172 tolower(p[2]) == 'g') {
173 logfile = "putty.log";
174 } else if (q == p + 7 &&
175 tolower(p[0]) == 'c' &&
176 tolower(p[1]) == 'l' &&
177 tolower(p[2]) == 'e' &&
178 tolower(p[3]) == 'a' &&
179 tolower(p[4]) == 'n' &&
180 tolower(p[5]) == 'u' &&
181 tolower(p[6]) == 'p') {
183 * `putty -cleanup'. Remove all registry entries
184 * associated with PuTTY, and also find and delete
185 * the random seed file.
188 "This procedure will remove ALL Registry\n"
189 "entries associated with PuTTY, and will\n"
190 "also remove the PuTTY random seed file.\n"
192 "THIS PROCESS WILL DESTROY YOUR SAVED\n"
193 "SESSIONS. Are you really sure you want\n"
196 MB_YESNO | MB_ICONWARNING) == IDYES) {
201 p = q + strspn(q, " \t");
205 * An initial @ means to activate a saved session.
209 while (i > 1 && isspace(p[i-1]))
212 do_defaults (p+1, &cfg);
213 if (!*cfg.host && !do_config()) {
217 } else if (*p == '&') {
219 * An initial & means we've been given a command line
220 * containing the hex value of a HANDLE for a file
221 * mapping object, which we must then extract as a
226 if (sscanf(p+1, "%p", &filemap) == 1 &&
227 (cp = MapViewOfFile(filemap, FILE_MAP_READ,
228 0, 0, sizeof(Config))) != NULL) {
231 CloseHandle(filemap);
232 } else if (!do_config()) {
239 * If the hostname starts with "telnet:", set the
240 * protocol to Telnet and process the string as a
243 if (!strncmp(q, "telnet:", 7)) {
247 if (q[0] == '/' && q[1] == '/')
249 cfg.protocol = PROT_TELNET;
251 while (*p && *p != ':' && *p != '/') p++;
259 strncpy (cfg.host, q, sizeof(cfg.host)-1);
260 cfg.host[sizeof(cfg.host)-1] = '\0';
262 while (*p && !isspace(*p)) p++;
265 strncpy (cfg.host, q, sizeof(cfg.host)-1);
266 cfg.host[sizeof(cfg.host)-1] = '\0';
267 while (*p && isspace(*p)) p++;
280 /* See if host is of the form user@host */
281 if (cfg.host[0] != '\0') {
282 char *atsign = strchr(cfg.host, '@');
283 /* Make sure we're not overflowing the user field */
285 if (atsign-cfg.host < sizeof cfg.username) {
286 strncpy (cfg.username, cfg.host, atsign-cfg.host);
287 cfg.username[atsign-cfg.host] = '\0';
289 memmove(cfg.host, atsign+1, 1+strlen(atsign+1));
295 * Select protocol. This is farmed out into a table in a
296 * separate file to enable an ssh-free variant.
301 for (i = 0; backends[i].backend != NULL; i++)
302 if (backends[i].protocol == cfg.protocol) {
303 back = backends[i].backend;
307 MessageBox(NULL, "Unsupported protocol number found",
308 "PuTTY Internal Error", MB_OK | MB_ICONEXCLAMATION);
314 real_ldisc = (cfg.ldisc_term ? &ldisc_term : &ldisc_simple);
315 /* To start with, we use the simple line discipline, so we can
316 * type passwords etc without fear of them being echoed... */
317 ldisc = &ldisc_simple;
321 wndclass.lpfnWndProc = WndProc;
322 wndclass.cbClsExtra = 0;
323 wndclass.cbWndExtra = 0;
324 wndclass.hInstance = inst;
325 wndclass.hIcon = LoadIcon (inst,
326 MAKEINTRESOURCE(IDI_MAINICON));
327 wndclass.hCursor = LoadCursor (NULL, IDC_IBEAM);
328 wndclass.hbrBackground = GetStockObject (BLACK_BRUSH);
329 wndclass.lpszMenuName = NULL;
330 wndclass.lpszClassName = appname;
332 RegisterClass (&wndclass);
337 savelines = cfg.savelines;
343 * Guess some defaults for the window size. This all gets
344 * updated later, so we don't really care too much. However, we
345 * do want the font width/height guesses to correspond to a
346 * large font rather than a small one...
353 term_size (cfg.height, cfg.width, cfg.savelines);
354 guess_width = extra_width + font_width * cols;
355 guess_height = extra_height + font_height * rows;
358 HWND w = GetDesktopWindow();
359 GetWindowRect (w, &r);
360 if (guess_width > r.right - r.left)
361 guess_width = r.right - r.left;
362 if (guess_height > r.bottom - r.top)
363 guess_height = r.bottom - r.top;
367 int winmode = WS_OVERLAPPEDWINDOW|WS_VSCROLL;
368 if (!cfg.scrollbar) winmode &= ~(WS_VSCROLL);
369 if (cfg.locksize) winmode &= ~(WS_THICKFRAME|WS_MAXIMIZEBOX);
370 hwnd = CreateWindow (appname, appname,
372 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 = calloc(size, 1);
413 caretbm = CreateBitmap(font_width, font_height, 1, 1, bits);
418 * Initialise the scroll bar.
423 si.cbSize = sizeof(si);
424 si.fMask = SIF_ALL | SIF_DISABLENOSCROLL;
429 SetScrollInfo (hwnd, SB_VERT, &si, FALSE);
433 * Start up the telnet connection.
437 char msg[1024], *title;
440 error = back->init (cfg.host, cfg.port, &realhost);
442 sprintf(msg, "Unable to open connection:\n%s", error);
443 MessageBox(NULL, msg, "PuTTY Error", MB_ICONERROR | MB_OK);
446 window_name = icon_name = NULL;
448 title = cfg.wintitle;
450 sprintf(msg, "%s - PuTTY", realhost);
457 session_closed = FALSE;
460 * Set up the input and output buffers.
463 outbuf_reap = outbuf_head = 0;
466 * Prepare the mouse handler.
468 lastact = MA_NOTHING;
469 lastbtn = MB_NOTHING;
470 dbltime = GetDoubleClickTime();
473 * Set up the session-control options on the system menu.
476 HMENU m = GetSystemMenu (hwnd, FALSE);
480 AppendMenu (m, MF_SEPARATOR, 0, 0);
481 if (cfg.protocol == PROT_TELNET) {
483 AppendMenu (p, MF_ENABLED, IDM_TEL_AYT, "Are You There");
484 AppendMenu (p, MF_ENABLED, IDM_TEL_BRK, "Break");
485 AppendMenu (p, MF_ENABLED, IDM_TEL_SYNCH, "Synch");
486 AppendMenu (p, MF_SEPARATOR, 0, 0);
487 AppendMenu (p, MF_ENABLED, IDM_TEL_EC, "Erase Character");
488 AppendMenu (p, MF_ENABLED, IDM_TEL_EL, "Erase Line");
489 AppendMenu (p, MF_ENABLED, IDM_TEL_GA, "Go Ahead");
490 AppendMenu (p, MF_ENABLED, IDM_TEL_NOP, "No Operation");
491 AppendMenu (p, MF_SEPARATOR, 0, 0);
492 AppendMenu (p, MF_ENABLED, IDM_TEL_ABORT, "Abort Process");
493 AppendMenu (p, MF_ENABLED, IDM_TEL_AO, "Abort Output");
494 AppendMenu (p, MF_ENABLED, IDM_TEL_IP, "Interrupt Process");
495 AppendMenu (p, MF_ENABLED, IDM_TEL_SUSP, "Suspend Process");
496 AppendMenu (p, MF_SEPARATOR, 0, 0);
497 AppendMenu (p, MF_ENABLED, IDM_TEL_EOR, "End Of Record");
498 AppendMenu (p, MF_ENABLED, IDM_TEL_EOF, "End Of File");
499 AppendMenu (m, MF_POPUP | MF_ENABLED, (UINT) p, "Telnet Command");
500 AppendMenu (m, MF_SEPARATOR, 0, 0);
502 AppendMenu (m, MF_ENABLED, IDM_SHOWLOG, "&Event Log");
503 AppendMenu (m, MF_SEPARATOR, 0, 0);
504 AppendMenu (m, MF_ENABLED, IDM_NEWSESS, "Ne&w Session...");
505 AppendMenu (m, MF_ENABLED, IDM_DUPSESS, "&Duplicate Session");
508 for (i = 1 ; i < ((nsessions < 256) ? nsessions : 256) ; i++)
509 AppendMenu (s, MF_ENABLED, IDM_SAVED_MIN + (16 * i) , sessions[i]);
510 AppendMenu (m, MF_POPUP | MF_ENABLED, (UINT) s, "Sa&ved Sessions");
511 AppendMenu (m, MF_ENABLED, IDM_RECONF, "Chan&ge Settings...");
512 AppendMenu (m, MF_SEPARATOR, 0, 0);
513 AppendMenu (m, MF_ENABLED, IDM_CLRSB, "C&lear Scrollback");
514 AppendMenu (m, MF_ENABLED, IDM_RESET, "Rese&t Terminal");
515 AppendMenu (m, MF_SEPARATOR, 0, 0);
516 AppendMenu (m, MF_ENABLED, IDM_ABOUT, "&About PuTTY");
520 * Finally show the window!
522 ShowWindow (hwnd, show);
525 * Set the palette up.
531 has_focus = (GetForegroundWindow() == hwnd);
534 if (GetMessage (&msg, NULL, 0, 0) == 1)
536 int timer_id = 0, long_timer = 0;
538 while (msg.message != WM_QUIT) {
539 /* Sometimes DispatchMessage calls routines that use their own
540 * GetMessage loop, setup this timer so we get some control back.
542 * Also call term_update() from the timer so that if the host
543 * is sending data flat out we still do redraws.
545 if(timer_id && long_timer) {
546 KillTimer(hwnd, timer_id);
547 long_timer = timer_id = 0;
550 timer_id = SetTimer(hwnd, 1, 20, NULL);
551 DispatchMessage (&msg);
553 /* Make sure we blink everything that needs it. */
556 /* Send the paste buffer if there's anything to send */
559 /* If there's nothing new in the queue then we can do everything
560 * we've delayed, reading the socket, writing, and repainting
563 if (PeekMessage (&msg, NULL, 0, 0, PM_REMOVE))
566 if (pending_netevent) {
567 enact_pending_netevent();
569 /* Force the cursor blink on */
572 if (PeekMessage (&msg, NULL, 0, 0, PM_REMOVE))
576 /* Okay there is now nothing to do so we make sure the screen is
577 * completely up to date then tell windows to call us in a little
581 KillTimer(hwnd, timer_id);
590 timer_id = SetTimer(hwnd, 1, 59500, NULL);
592 timer_id = SetTimer(hwnd, 1, 250, NULL);
595 /* There's no point rescanning everything in the message queue
596 * so we do an apperently unneccesary wait here
599 if (GetMessage (&msg, NULL, 0, 0) != 1)
611 DeleteObject(fonts[i]);
618 if (cfg.protocol == PROT_SSH) {
629 * Set up, or shut down, an AsyncSelect. Called from winnet.c.
631 char *do_select(SOCKET skt, int startup) {
635 events = FD_READ | FD_WRITE | FD_OOB | FD_CLOSE;
640 return "do_select(): internal error (hwnd==NULL)";
641 if (WSAAsyncSelect (skt, hwnd, msg, events) == SOCKET_ERROR) {
642 switch (WSAGetLastError()) {
643 case WSAENETDOWN: return "Network is down";
644 default: return "WSAAsyncSelect(): unknown error";
651 * Print a message box and close the connection.
653 void connection_fatal(char *fmt, ...) {
658 vsprintf(stuff, fmt, ap);
660 MessageBox(hwnd, stuff, "PuTTY Fatal Error", MB_ICONERROR | MB_OK);
661 if (cfg.close_on_exit)
664 session_closed = TRUE;
665 SetWindowText (hwnd, "PuTTY (inactive)");
670 * Actually do the job requested by a WM_NETEVENT
672 static void enact_pending_netevent(void) {
673 static int reentering = 0;
674 extern int select_result(WPARAM, LPARAM);
678 return; /* don't unpend the pending */
680 pending_netevent = FALSE;
683 ret = select_result (pend_netevent_wParam, pend_netevent_lParam);
687 if (cfg.close_on_exit)
690 session_closed = TRUE;
691 MessageBox(hwnd, "Connection closed by remote host",
692 "PuTTY", MB_OK | MB_ICONINFORMATION);
693 SetWindowText (hwnd, "PuTTY (inactive)");
699 * Copy the colour palette from the configuration data into defpal.
700 * This is non-trivial because the colour indices are different.
702 static void cfgtopalette(void) {
704 static const int ww[] = {
705 6, 7, 8, 9, 10, 11, 12, 13,
706 14, 15, 16, 17, 18, 19, 20, 21,
707 0, 1, 2, 3, 4, 4, 5, 5
710 for (i=0; i<24; i++) {
712 defpal[i].rgbtRed = cfg.colours[w][0];
713 defpal[i].rgbtGreen = cfg.colours[w][1];
714 defpal[i].rgbtBlue = cfg.colours[w][2];
719 * Set up the colour palette.
721 static void init_palette(void) {
723 HDC hdc = GetDC (hwnd);
725 if (cfg.try_palette &&
726 GetDeviceCaps (hdc, RASTERCAPS) & RC_PALETTE) {
727 logpal = smalloc(sizeof(*logpal)
728 - sizeof(logpal->palPalEntry)
729 + NCOLOURS * sizeof(PALETTEENTRY));
730 logpal->palVersion = 0x300;
731 logpal->palNumEntries = NCOLOURS;
732 for (i = 0; i < NCOLOURS; i++) {
733 logpal->palPalEntry[i].peRed = defpal[i].rgbtRed;
734 logpal->palPalEntry[i].peGreen = defpal[i].rgbtGreen;
735 logpal->palPalEntry[i].peBlue = defpal[i].rgbtBlue;
736 logpal->palPalEntry[i].peFlags = PC_NOCOLLAPSE;
738 pal = CreatePalette (logpal);
740 SelectPalette (hdc, pal, FALSE);
741 RealizePalette (hdc);
742 SelectPalette (hdc, GetStockObject (DEFAULT_PALETTE),
746 ReleaseDC (hwnd, hdc);
749 for (i=0; i<NCOLOURS; i++)
750 colours[i] = PALETTERGB(defpal[i].rgbtRed,
754 for(i=0; i<NCOLOURS; i++)
755 colours[i] = RGB(defpal[i].rgbtRed,
761 * Initialise all the fonts we will need. There may be as many as
762 * eight or as few as one. We also:
764 * - check the font width and height, correcting our guesses if
767 * - verify that the bold font is the same width as the ordinary
768 * one, and engage shadow bolding if not.
770 * - verify that the underlined font is the same width as the
771 * ordinary one (manual underlining by means of line drawing can
772 * be done in a pinch).
774 static void init_fonts(int pick_width) {
779 int fw_dontcare, fw_bold;
788 if (cfg.fontisbold) {
789 fw_dontcare = FW_BOLD;
792 fw_dontcare = FW_DONTCARE;
798 font_height = cfg.fontheight;
799 font_width = pick_width;
802 fonts[i] = CreateFont (font_height, font_width, 0, 0, w, FALSE, u, FALSE, \
803 c, OUT_DEFAULT_PRECIS, \
804 CLIP_DEFAULT_PRECIS, DEFAULT_QUALITY, \
805 FIXED_PITCH | FF_DONTCARE, cfg.font)
807 if (cfg.vtmode != VT_OEMONLY) {
808 f(FONT_NORMAL, cfg.fontcharset, fw_dontcare, FALSE);
810 SelectObject (hdc, fonts[FONT_NORMAL]);
811 GetTextMetrics(hdc, &tm);
812 font_height = tm.tmHeight;
813 font_width = tm.tmAveCharWidth;
815 f(FONT_UNDERLINE, cfg.fontcharset, fw_dontcare, TRUE);
818 * Some fonts, e.g. 9-pt Courier, draw their underlines
819 * outside their character cell. We successfully prevent
820 * screen corruption by clipping the text output, but then
821 * we lose the underline completely. Here we try to work
822 * out whether this is such a font, and if it is, we set a
823 * flag that causes underlines to be drawn by hand.
825 * Having tried other more sophisticated approaches (such
826 * as examining the TEXTMETRIC structure or requesting the
827 * height of a string), I think we'll do this the brute
828 * force way: we create a small bitmap, draw an underlined
829 * space on it, and test to see whether any pixels are
830 * foreground-coloured. (Since we expect the underline to
831 * go all the way across the character cell, we only search
832 * down a single column of the bitmap, half way across.)
836 HBITMAP und_bm, und_oldbm;
840 und_dc = CreateCompatibleDC(hdc);
841 und_bm = CreateCompatibleBitmap(hdc, font_width, font_height);
842 und_oldbm = SelectObject(und_dc, und_bm);
843 SelectObject(und_dc, fonts[FONT_UNDERLINE]);
844 SetTextAlign(und_dc, TA_TOP | TA_LEFT | TA_NOUPDATECP);
845 SetTextColor (und_dc, RGB(255,255,255));
846 SetBkColor (und_dc, RGB(0,0,0));
847 SetBkMode (und_dc, OPAQUE);
848 ExtTextOut (und_dc, 0, 0, ETO_OPAQUE, NULL, " ", 1, NULL);
850 for (i = 0; i < font_height; i++) {
851 c = GetPixel(und_dc, font_width/2, i);
855 SelectObject(und_dc, und_oldbm);
856 DeleteObject(und_bm);
858 font_needs_hand_underlining = !gotit;
861 if (bold_mode == BOLD_FONT) {
862 f(FONT_BOLD, cfg.fontcharset, fw_bold, FALSE);
863 f(FONT_BOLDUND, cfg.fontcharset, fw_bold, TRUE);
866 if (cfg.vtmode == VT_OEMANSI) {
867 f(FONT_OEM, OEM_CHARSET, fw_dontcare, FALSE);
868 f(FONT_OEMUND, OEM_CHARSET, fw_dontcare, TRUE);
870 if (bold_mode == BOLD_FONT) {
871 f(FONT_OEMBOLD, OEM_CHARSET, fw_bold, FALSE);
872 f(FONT_OEMBOLDUND, OEM_CHARSET, fw_bold, TRUE);
878 f(FONT_OEM, cfg.fontcharset, fw_dontcare, FALSE);
880 SelectObject (hdc, fonts[FONT_OEM]);
881 GetTextMetrics(hdc, &tm);
882 font_height = tm.tmHeight;
883 font_width = tm.tmAveCharWidth;
885 f(FONT_OEMUND, cfg.fontcharset, fw_dontcare, TRUE);
887 if (bold_mode == BOLD_FONT) {
888 f(FONT_BOLD, cfg.fontcharset, fw_bold, FALSE);
889 f(FONT_BOLDUND, cfg.fontcharset, fw_bold, TRUE);
894 descent = tm.tmAscent + 1;
895 if (descent >= font_height)
896 descent = font_height - 1;
897 firstchar = tm.tmFirstChar;
899 for (i=0; i<8; i++) {
901 if (SelectObject (hdc, fonts[i]) &&
902 GetTextMetrics(hdc, &tm) )
903 fsize[i] = tm.tmAveCharWidth + 256 * tm.tmHeight;
909 ReleaseDC (hwnd, hdc);
911 /* ... This is wrong in OEM only mode */
912 if (fsize[FONT_UNDERLINE] != fsize[FONT_NORMAL] ||
913 (bold_mode == BOLD_FONT &&
914 fsize[FONT_BOLDUND] != fsize[FONT_BOLD])) {
916 DeleteObject (fonts[FONT_UNDERLINE]);
917 if (bold_mode == BOLD_FONT)
918 DeleteObject (fonts[FONT_BOLDUND]);
921 if (bold_mode == BOLD_FONT &&
922 fsize[FONT_BOLD] != fsize[FONT_NORMAL]) {
923 bold_mode = BOLD_SHADOW;
924 DeleteObject (fonts[FONT_BOLD]);
925 if (und_mode == UND_FONT)
926 DeleteObject (fonts[FONT_BOLDUND]);
930 /* With the fascist font painting it doesn't matter if the linedraw font
931 * isn't exactly the right size anymore so we don't have to check this.
933 if (cfg.vtmode == VT_OEMANSI && fsize[FONT_OEM] != fsize[FONT_NORMAL] ) {
934 if( cfg.fontcharset == OEM_CHARSET )
936 MessageBox(NULL, "The OEM and ANSI versions of this font are\n"
937 "different sizes. Using OEM-only mode instead",
938 "Font Size Mismatch", MB_ICONINFORMATION | MB_OK);
939 cfg.vtmode = VT_OEMONLY;
941 else if( firstchar < ' ' )
943 MessageBox(NULL, "The OEM and ANSI versions of this font are\n"
944 "different sizes. Using XTerm mode instead",
945 "Font Size Mismatch", MB_ICONINFORMATION | MB_OK);
946 cfg.vtmode = VT_XWINDOWS;
950 MessageBox(NULL, "The OEM and ANSI versions of this font are\n"
951 "different sizes. Using ISO8859-1 mode instead",
952 "Font Size Mismatch", MB_ICONINFORMATION | MB_OK);
953 cfg.vtmode = VT_POORMAN;
958 DeleteObject (fonts[i]);
964 void request_resize (int w, int h, int refont) {
967 /* If the window is maximized supress resizing attempts */
968 if(IsZoomed(hwnd)) return;
971 /* Don't do this in OEMANSI, you may get disable messages */
972 if (refont && w != cols && (cols==80 || cols==132)
973 && cfg.vtmode != VT_OEMANSI)
975 if (refont && w != cols && (cols==80 || cols==132))
978 /* If font width too big for screen should we shrink the font more ? */
980 font_width = ((font_width*cols+w/2)/w);
987 DeleteObject(fonts[i]);
989 bold_mode = cfg.bold_colour ? BOLD_COLOURS : BOLD_FONT;
991 init_fonts(font_width);
995 static int first_time = 1;
1001 /* Get the size of the screen */
1002 if (GetClientRect(GetDesktopWindow(),&ss))
1003 /* first_time = 0 */;
1004 else { first_time = 2; break; }
1006 /* Make sure the values are sane */
1007 width = (ss.right-ss.left-extra_width ) / font_width;
1008 height = (ss.bottom-ss.top-extra_height ) / font_height;
1010 if (w>width) w=width;
1011 if (h>height) h=height;
1017 width = extra_width + font_width * w;
1018 height = extra_height + font_height * h;
1020 SetWindowPos (hwnd, NULL, 0, 0, width, height,
1021 SWP_NOACTIVATE | SWP_NOCOPYBITS |
1022 SWP_NOMOVE | SWP_NOZORDER);
1025 static void click (Mouse_Button b, int x, int y) {
1026 int thistime = GetMessageTime();
1028 if (lastbtn == b && thistime - lasttime < dbltime) {
1029 lastact = (lastact == MA_CLICK ? MA_2CLK :
1030 lastact == MA_2CLK ? MA_3CLK :
1031 lastact == MA_3CLK ? MA_CLICK : MA_NOTHING);
1036 if (lastact != MA_NOTHING)
1037 term_mouse (b, lastact, x, y);
1038 lasttime = thistime;
1041 static LRESULT CALLBACK WndProc (HWND hwnd, UINT message,
1042 WPARAM wParam, LPARAM lParam) {
1044 static int ignore_size = FALSE;
1045 static int ignore_clip = FALSE;
1046 static int just_reconfigged = FALSE;
1047 static int resizing = FALSE;
1051 if (pending_netevent)
1052 enact_pending_netevent();
1059 if (cfg.ping_interval > 0)
1063 if (now-last_movement > cfg.ping_interval * 60 - 10)
1065 back->special(TS_PING);
1066 last_movement = now;
1073 if (!cfg.warn_on_close || session_closed ||
1074 MessageBox(hwnd, "Are you sure you want to close this session?",
1075 "PuTTY Exit Confirmation",
1076 MB_ICONWARNING | MB_OKCANCEL) == IDOK)
1077 DestroyWindow(hwnd);
1080 PostQuitMessage (0);
1083 switch (wParam & ~0xF) { /* low 4 bits reserved to Windows */
1095 PROCESS_INFORMATION pi;
1096 HANDLE filemap = NULL;
1098 if (wParam == IDM_DUPSESS) {
1100 * Allocate a file-mapping memory chunk for the
1103 SECURITY_ATTRIBUTES sa;
1106 sa.nLength = sizeof(sa);
1107 sa.lpSecurityDescriptor = NULL;
1108 sa.bInheritHandle = TRUE;
1109 filemap = CreateFileMapping((HANDLE)0xFFFFFFFF,
1116 p = (Config *)MapViewOfFile(filemap,
1118 0, 0, sizeof(Config));
1120 *p = cfg; /* structure copy */
1124 sprintf(c, "putty &%p", filemap);
1126 } else if (wParam == IDM_SAVEDSESS) {
1127 char *session = sessions[(lParam - IDM_SAVED_MIN) / 16];
1128 cl = malloc(16 + strlen(session)); /* 8, but play safe */
1130 cl = NULL; /* not a very important failure mode */
1132 sprintf(cl, "putty @%s", session);
1138 GetModuleFileName (NULL, b, sizeof(b)-1);
1140 si.lpReserved = NULL;
1141 si.lpDesktop = NULL;
1145 si.lpReserved2 = NULL;
1146 CreateProcess (b, cl, NULL, NULL, TRUE,
1147 NORMAL_PRIORITY_CLASS, NULL, NULL, &si, &pi);
1150 CloseHandle(filemap);
1156 if (!do_reconfig(hwnd))
1158 just_reconfigged = TRUE;
1163 DeleteObject(fonts[i]);
1165 bold_mode = cfg.bold_colour ? BOLD_COLOURS : BOLD_FONT;
1166 und_mode = UND_FONT;
1169 /* Telnet will change local echo -> remote if the remote asks */
1170 if (cfg.protocol != PROT_TELNET)
1171 ldisc = (cfg.ldisc_term ? &ldisc_term : &ldisc_simple);
1179 /* Enable or disable the scroll bar, etc */
1181 LONG nflg, flag = GetWindowLong(hwnd, GWL_STYLE);
1184 if (cfg.scrollbar) nflg |= WS_VSCROLL;
1185 else nflg &= ~WS_VSCROLL;
1187 nflg &= ~(WS_THICKFRAME|WS_MAXIMIZEBOX);
1189 nflg |= (WS_THICKFRAME|WS_MAXIMIZEBOX);
1195 SetWindowLong(hwnd, GWL_STYLE, nflg);
1196 SendMessage (hwnd, WM_IGNORE_SIZE, 0, 0);
1197 SetWindowPos(hwnd, NULL, 0,0,0,0,
1198 SWP_NOACTIVATE|SWP_NOCOPYBITS|
1199 SWP_NOMOVE|SWP_NOSIZE| SWP_NOZORDER|
1202 GetWindowRect (hwnd, &wr);
1203 GetClientRect (hwnd, &cr);
1204 extra_width = wr.right - wr.left - cr.right + cr.left;
1205 extra_height = wr.bottom - wr.top - cr.bottom + cr.top;
1209 term_size(cfg.height, cfg.width, cfg.savelines);
1210 InvalidateRect(hwnd, NULL, TRUE);
1211 SetWindowPos (hwnd, NULL, 0, 0,
1212 extra_width + font_width * cfg.width,
1213 extra_height + font_height * cfg.height,
1214 SWP_NOACTIVATE | SWP_NOCOPYBITS |
1215 SWP_NOMOVE | SWP_NOZORDER);
1216 if (IsIconic(hwnd)) {
1217 SetWindowText (hwnd,
1218 cfg.win_name_always ? window_name : icon_name);
1227 case IDM_TEL_AYT: back->special (TS_AYT); break;
1228 case IDM_TEL_BRK: back->special (TS_BRK); break;
1229 case IDM_TEL_SYNCH: back->special (TS_SYNCH); break;
1230 case IDM_TEL_EC: back->special (TS_EC); break;
1231 case IDM_TEL_EL: back->special (TS_EL); break;
1232 case IDM_TEL_GA: back->special (TS_GA); break;
1233 case IDM_TEL_NOP: back->special (TS_NOP); break;
1234 case IDM_TEL_ABORT: back->special (TS_ABORT); break;
1235 case IDM_TEL_AO: back->special (TS_AO); break;
1236 case IDM_TEL_IP: back->special (TS_IP); break;
1237 case IDM_TEL_SUSP: back->special (TS_SUSP); break;
1238 case IDM_TEL_EOR: back->special (TS_EOR); break;
1239 case IDM_TEL_EOF: back->special (TS_EOF); break;
1244 if (wParam >= IDM_SAVED_MIN && wParam <= IDM_SAVED_MAX) {
1245 SendMessage(hwnd, WM_SYSCOMMAND, IDM_SAVEDSESS, wParam);
1250 #define X_POS(l) ((int)(short)LOWORD(l))
1251 #define Y_POS(l) ((int)(short)HIWORD(l))
1253 #define TO_CHR_X(x) (((x)<0 ? (x)-font_width+1 : (x)) / font_width)
1254 #define TO_CHR_Y(y) (((y)<0 ? (y)-font_height+1: (y)) / font_height)
1256 case WM_LBUTTONDOWN:
1257 click (MB_SELECT, TO_CHR_X(X_POS(lParam)),
1258 TO_CHR_Y(Y_POS(lParam)));
1262 term_mouse (MB_SELECT, MA_RELEASE, TO_CHR_X(X_POS(lParam)),
1263 TO_CHR_Y(Y_POS(lParam)));
1266 case WM_MBUTTONDOWN:
1268 click (cfg.mouse_is_xterm ? MB_PASTE : MB_EXTEND,
1269 TO_CHR_X(X_POS(lParam)),
1270 TO_CHR_Y(Y_POS(lParam)));
1273 term_mouse (cfg.mouse_is_xterm ? MB_PASTE : MB_EXTEND,
1274 MA_RELEASE, TO_CHR_X(X_POS(lParam)),
1275 TO_CHR_Y(Y_POS(lParam)));
1278 case WM_RBUTTONDOWN:
1280 click (cfg.mouse_is_xterm ? MB_EXTEND : MB_PASTE,
1281 TO_CHR_X(X_POS(lParam)),
1282 TO_CHR_Y(Y_POS(lParam)));
1285 term_mouse (cfg.mouse_is_xterm ? MB_EXTEND : MB_PASTE,
1286 MA_RELEASE, TO_CHR_X(X_POS(lParam)),
1287 TO_CHR_Y(Y_POS(lParam)));
1292 * Add the mouse position and message time to the random
1295 noise_ultralight(lParam);
1297 if (wParam & (MK_LBUTTON | MK_MBUTTON | MK_RBUTTON)) {
1299 if (wParam & MK_LBUTTON)
1301 else if (wParam & MK_MBUTTON)
1302 b = cfg.mouse_is_xterm ? MB_PASTE : MB_EXTEND;
1304 b = cfg.mouse_is_xterm ? MB_EXTEND : MB_PASTE;
1305 term_mouse (b, MA_DRAG, TO_CHR_X(X_POS(lParam)),
1306 TO_CHR_Y(Y_POS(lParam)));
1309 case WM_IGNORE_CLIP:
1310 ignore_clip = wParam; /* don't panic on DESTROYCLIPBOARD */
1312 case WM_DESTROYCLIPBOARD:
1315 ignore_clip = FALSE;
1321 hdc = BeginPaint (hwnd, &p);
1323 SelectPalette (hdc, pal, TRUE);
1324 RealizePalette (hdc);
1326 term_paint (hdc, p.rcPaint.left, p.rcPaint.top,
1327 p.rcPaint.right, p.rcPaint.bottom);
1328 SelectObject (hdc, GetStockObject(SYSTEM_FONT));
1329 SelectObject (hdc, GetStockObject(WHITE_PEN));
1330 EndPaint (hwnd, &p);
1335 /* Notice we can get multiple netevents, FD_READ, FD_WRITE etc
1336 * but the only one that's likely to try to overload us is FD_READ.
1337 * This means buffering just one is fine.
1339 if (pending_netevent)
1340 enact_pending_netevent();
1342 pending_netevent = TRUE;
1343 pend_netevent_wParam=wParam;
1344 pend_netevent_lParam=lParam;
1345 time(&last_movement);
1349 CreateCaret(hwnd, caretbm, 0, 0);
1360 case WM_IGNORE_SIZE:
1361 ignore_size = TRUE; /* don't panic on next WM_SIZE msg */
1363 case WM_ENTERSIZEMOVE:
1367 case WM_EXITSIZEMOVE:
1374 int width, height, w, h, ew, eh;
1375 LPRECT r = (LPRECT)lParam;
1377 width = r->right - r->left - extra_width;
1378 height = r->bottom - r->top - extra_height;
1379 w = (width + font_width/2) / font_width; if (w < 1) w = 1;
1380 h = (height + font_height/2) / font_height; if (h < 1) h = 1;
1381 UpdateSizeTip(hwnd, w, h);
1382 ew = width - w * font_width;
1383 eh = height - h * font_height;
1385 if (wParam == WMSZ_LEFT ||
1386 wParam == WMSZ_BOTTOMLEFT ||
1387 wParam == WMSZ_TOPLEFT)
1393 if (wParam == WMSZ_TOP ||
1394 wParam == WMSZ_TOPRIGHT ||
1395 wParam == WMSZ_TOPLEFT)
1405 /* break; (never reached) */
1407 if (wParam == SIZE_MINIMIZED) {
1408 SetWindowText (hwnd,
1409 cfg.win_name_always ? window_name : icon_name);
1412 if (wParam == SIZE_RESTORED || wParam == SIZE_MAXIMIZED)
1413 SetWindowText (hwnd, window_name);
1415 int width, height, w, h;
1416 #if 0 /* we have fixed this using WM_SIZING now */
1420 width = LOWORD(lParam);
1421 height = HIWORD(lParam);
1422 w = width / font_width; if (w < 1) w = 1;
1423 h = height / font_height; if (h < 1) h = 1;
1424 #if 0 /* we have fixed this using WM_SIZING now */
1425 ew = width - w * font_width;
1426 eh = height - h * font_height;
1427 if (ew != 0 || eh != 0) {
1429 GetWindowRect (hwnd, &r);
1430 SendMessage (hwnd, WM_IGNORE_SIZE, 0, 0);
1431 SetWindowPos (hwnd, NULL, 0, 0,
1432 r.right - r.left - ew, r.bottom - r.top - eh,
1433 SWP_NOACTIVATE | SWP_NOMOVE | SWP_NOZORDER);
1436 if (w != cols || h != rows || just_reconfigged) {
1438 term_size (h, w, cfg.savelines);
1440 * Don't call back->size in mid-resize. (To prevent
1441 * massive numbers of resize events getting sent
1442 * down the connection during an NT opaque drag.)
1446 just_reconfigged = FALSE;
1449 ignore_size = FALSE;
1452 switch (LOWORD(wParam)) {
1453 case SB_BOTTOM: term_scroll(-1, 0); break;
1454 case SB_TOP: term_scroll(+1, 0); break;
1455 case SB_LINEDOWN: term_scroll (0, +1); break;
1456 case SB_LINEUP: term_scroll (0, -1); break;
1457 case SB_PAGEDOWN: term_scroll (0, +rows/2); break;
1458 case SB_PAGEUP: term_scroll (0, -rows/2); break;
1459 case SB_THUMBPOSITION: case SB_THUMBTRACK:
1460 term_scroll (1, HIWORD(wParam)); break;
1463 case WM_PALETTECHANGED:
1464 if ((HWND) wParam != hwnd && pal != NULL) {
1465 HDC hdc = get_ctx();
1467 if (RealizePalette (hdc) > 0)
1473 case WM_QUERYNEWPALETTE:
1475 HDC hdc = get_ctx();
1477 if (RealizePalette (hdc) > 0)
1489 * Add the scan code and keypress timing to the random
1492 noise_ultralight(lParam);
1495 * We don't do TranslateMessage since it disassociates the
1496 * resulting CHAR message from the KEYDOWN that sparked it,
1497 * which we occasionally don't want. Instead, we process
1498 * KEYDOWN, and call the Win32 translator functions so that
1499 * we get the translations under _our_ control.
1502 unsigned char buf[20];
1505 if (wParam==VK_PROCESSKEY) {
1508 m.message = WM_KEYDOWN;
1510 m.lParam = lParam & 0xdfff;
1511 TranslateMessage(&m);
1513 len = TranslateKey (message, wParam, lParam, buf);
1515 return DefWindowProc (hwnd, message, wParam, lParam);
1516 ldisc->send (buf, len);
1522 unsigned char buf[2];
1525 buf[0] = wParam >> 8;
1526 ldisc->send (buf, 2);
1531 * Nevertheless, we are prepared to deal with WM_CHAR
1532 * messages, should they crop up. So if someone wants to
1533 * post the things to us as part of a macro manoeuvre,
1534 * we're ready to cope.
1537 char c = xlat_kbd2tty((unsigned char)wParam);
1538 ldisc->send (&c, 1);
1543 return DefWindowProc (hwnd, message, wParam, lParam);
1547 * Move the system caret. (We maintain one, even though it's
1548 * invisible, for the benefit of blind people: apparently some
1549 * helper software tracks the system caret, so we should arrange to
1552 void sys_cursor(int x, int y) {
1553 SetCaretPos(x * font_width, y * font_height);
1557 * Draw a line of text in the window, at given character
1558 * coordinates, in given attributes.
1560 * We are allowed to fiddle with the contents of `text'.
1562 void do_text (Context ctx, int x, int y, char *text, int len,
1563 unsigned long attr, int lattr) {
1565 int nfg, nbg, nfont;
1568 int force_manual_underline = 0;
1569 int fnt_width = font_width*(1+(lattr!=LATTR_NORM));
1570 static int *IpDx = 0, IpDxLEN = 0;;
1572 if (len>IpDxLEN || IpDx[0] != fnt_width) {
1576 IpDx = smalloc((len+16)*sizeof(int));
1579 for(i=0; i<IpDxLEN; i++)
1580 IpDx[i] = fnt_width;
1586 if (attr & ATTR_ACTCURS) {
1587 attr &= (bold_mode == BOLD_COLOURS ? 0x300200 : 0x300300);
1588 attr ^= ATTR_CUR_XOR;
1592 if (cfg.vtmode == VT_OEMONLY)
1596 * Map high-half characters in order to approximate ISO using
1597 * OEM character set. No characters are missing if the OEM codepage
1600 if (nfont & FONT_OEM) {
1602 for (i=0; i<len; i++)
1603 if (text[i] >= '\xA0' && text[i] <= '\xFF') {
1605 /* This is CP850 ... perfect translation */
1606 static const char oemhighhalf[] =
1607 "\x20\xAD\xBD\x9C\xCF\xBE\xDD\xF5" /* A0-A7 */
1608 "\xF9\xB8\xA6\xAE\xAA\xF0\xA9\xEE" /* A8-AF */
1609 "\xF8\xF1\xFD\xFC\xEF\xE6\xF4\xFA" /* B0-B7 */
1610 "\xF7\xFB\xA7\xAF\xAC\xAB\xF3\xA8" /* B8-BF */
1611 "\xB7\xB5\xB6\xC7\x8E\x8F\x92\x80" /* C0-C7 */
1612 "\xD4\x90\xD2\xD3\xDE\xD6\xD7\xD8" /* C8-CF */
1613 "\xD1\xA5\xE3\xE0\xE2\xE5\x99\x9E" /* D0-D7 */
1614 "\x9D\xEB\xE9\xEA\x9A\xED\xE8\xE1" /* D8-DF */
1615 "\x85\xA0\x83\xC6\x84\x86\x91\x87" /* E0-E7 */
1616 "\x8A\x82\x88\x89\x8D\xA1\x8C\x8B" /* E8-EF */
1617 "\xD0\xA4\x95\xA2\x93\xE4\x94\xF6" /* F0-F7 */
1618 "\x9B\x97\xA3\x96\x81\xEC\xE7\x98" /* F8-FF */
1621 /* This is CP437 ... junk translation */
1622 static const unsigned char oemhighhalf[] = {
1623 0xff, 0xad, 0x9b, 0x9c, 0x6f, 0x9d, 0x7c, 0x15,
1624 0x22, 0x43, 0xa6, 0xae, 0xaa, 0x2d, 0x52, 0xc4,
1625 0xf8, 0xf1, 0xfd, 0x33, 0x27, 0xe6, 0x14, 0xfa,
1626 0x2c, 0x31, 0xa7, 0xaf, 0xac, 0xab, 0x2f, 0xa8,
1627 0x41, 0x41, 0x41, 0x41, 0x8e, 0x8f, 0x92, 0x80,
1628 0x45, 0x90, 0x45, 0x45, 0x49, 0x49, 0x49, 0x49,
1629 0x44, 0xa5, 0x4f, 0x4f, 0x4f, 0x4f, 0x99, 0x78,
1630 0xed, 0x55, 0x55, 0x55, 0x9a, 0x59, 0x50, 0xe1,
1631 0x85, 0xa0, 0x83, 0x61, 0x84, 0x86, 0x91, 0x87,
1632 0x8a, 0x82, 0x88, 0x89, 0x8d, 0xa1, 0x8c, 0x8b,
1633 0x0b, 0xa4, 0x95, 0xa2, 0x93, 0x6f, 0x94, 0xf6,
1634 0xed, 0x97, 0xa3, 0x96, 0x81, 0x79, 0x70, 0x98
1637 text[i] = oemhighhalf[(unsigned char)text[i] - 0xA0];
1641 if (attr & ATTR_LINEDRW) {
1644 static const char poorman[] =
1645 "*#****\xB0\xB1**+++++-----++++|****\xA3\xB7";
1648 static const char oemmap_437[] =
1649 "\x04\xB1****\xF8\xF1**\xD9\xBF\xDA\xC0\xC5"
1650 "\xC4\xC4\xC4\xC4\xC4\xC3\xB4\xC1\xC2\xB3\xF3\xF2\xE3*\x9C\xFA";
1653 static const char oemmap_850[] =
1654 "\x04\xB1****\xF8\xF1**\xD9\xBF\xDA\xC0\xC5"
1655 "\xC4\xC4\xC4\xC4\xC4\xC3\xB4\xC1\xC2\xB3****\x9C\xFA";
1657 /* Poor windows font ... eg: windows courier */
1658 static const char oemmap[] =
1659 "*\xB1****\xF8\xF1**\xD9\xBF\xDA\xC0\xC5"
1660 "\xC4\xC4\xC4\xC4\xC4\xC3\xB4\xC1\xC2\xB3****\x9C\xFA";
1663 * Line drawing mapping: map ` thru ~ (0x60 thru 0x7E) to
1664 * VT100 line drawing chars; everything else stays normal.
1666 * Actually '_' maps to space too, but that's done before.
1668 switch (cfg.vtmode) {
1670 for (i=0; i<len; i++)
1671 if (text[i] >= '\x60' && text[i] <= '\x7E')
1672 text[i] += '\x01' - '\x60';
1675 /* Make sure we actually have an OEM font */
1676 if (fonts[nfont|FONT_OEM]) {
1679 for (i=0; i<len; i++)
1680 if (text[i] >= '\x60' && text[i] <= '\x7E')
1681 text[i] = oemmap[(unsigned char)text[i] - 0x60];
1685 for (i=0; i<len; i++)
1686 if (text[i] >= '\x60' && text[i] <= '\x7E')
1687 text[i] = poorman[(unsigned char)text[i] - 0x60];
1692 nfg = 2 * ((attr & ATTR_FGMASK) >> ATTR_FGSHIFT);
1693 nbg = 2 * ((attr & ATTR_BGMASK) >> ATTR_BGSHIFT);
1694 if (bold_mode == BOLD_FONT && (attr & ATTR_BOLD))
1696 if (und_mode == UND_FONT && (attr & ATTR_UNDER))
1697 nfont |= FONT_UNDERLINE;
1700 if (nfont&FONT_UNDERLINE)
1701 force_manual_underline = 1;
1702 /* Don't do the same for manual bold, it could be bad news. */
1704 nfont &= ~(FONT_BOLD|FONT_UNDERLINE);
1706 if (font_needs_hand_underlining && (attr & ATTR_UNDER))
1707 force_manual_underline = 1;
1708 if (attr & ATTR_REVERSE) {
1709 t = nfg; nfg = nbg; nbg = t;
1711 if (bold_mode == BOLD_COLOURS && (attr & ATTR_BOLD))
1713 if (bold_mode == BOLD_COLOURS && (attr & ATTR_BLINK))
1717 SelectObject (hdc, fonts[nfont]);
1718 SetTextColor (hdc, fg);
1719 SetBkColor (hdc, bg);
1720 SetBkMode (hdc, OPAQUE);
1723 line_box.right = x+fnt_width*len;
1724 line_box.bottom = y+font_height;
1725 ExtTextOut (hdc, x, y, ETO_CLIPPED|ETO_OPAQUE, &line_box, text, len, IpDx);
1726 if (bold_mode == BOLD_SHADOW && (attr & ATTR_BOLD)) {
1727 SetBkMode (hdc, TRANSPARENT);
1729 /* GRR: This draws the character outside it's box and can leave
1730 * 'droppings' even with the clip box! I suppose I could loop it
1731 * one character at a time ... yuk.
1733 * Or ... I could do a test print with "W", and use +1 or -1 for this
1734 * shift depending on if the leftmost column is blank...
1736 ExtTextOut (hdc, x-1, y, ETO_CLIPPED, &line_box, text, len, IpDx);
1738 if (force_manual_underline ||
1739 (und_mode == UND_LINE && (attr & ATTR_UNDER))) {
1741 oldpen = SelectObject (hdc, CreatePen(PS_SOLID, 0, fg));
1742 MoveToEx (hdc, x, y+descent, NULL);
1743 LineTo (hdc, x+len*fnt_width, y+descent);
1744 oldpen = SelectObject (hdc, oldpen);
1745 DeleteObject (oldpen);
1747 if (attr & ATTR_PASCURS) {
1750 pts[0].x = pts[1].x = pts[4].x = x;
1751 pts[2].x = pts[3].x = x+fnt_width-1;
1752 pts[0].y = pts[3].y = pts[4].y = y;
1753 pts[1].y = pts[2].y = y+font_height-1;
1754 oldpen = SelectObject (hdc, CreatePen(PS_SOLID, 0, colours[23]));
1755 Polyline (hdc, pts, 5);
1756 oldpen = SelectObject (hdc, oldpen);
1757 DeleteObject (oldpen);
1761 static int check_compose(int first, int second) {
1763 static char * composetbl[] = {
1764 "++#", "AA@", "(([", "//\\", "))]", "(-{", "-)}", "/^|", "!!¡", "C/¢",
1765 "C|¢", "L-£", "L=£", "XO¤", "X0¤", "Y-¥", "Y=¥", "||¦", "SO§", "S!§",
1766 "S0§", "\"\"¨", "CO©", "C0©", "A_ª", "<<«", ",-¬", "--", "RO®",
1767 "-^¯", "0^°", "+-±", "2^²", "3^³", "''´", "/Uµ", "P!¶", ".^·", ",,¸",
1768 "1^¹", "O_º", ">>»", "14¼", "12½", "34¾", "??¿", "`AÀ", "'AÁ", "^AÂ",
1769 "~AÃ", "\"AÄ", "*AÅ", "AEÆ", ",CÇ", "`EÈ", "'EÉ", "^EÊ", "\"EË",
1770 "`IÌ", "'IÍ", "^IÎ", "\"IÏ", "-DÐ", "~NÑ", "`OÒ", "'OÓ", "^OÔ",
1771 "~OÕ", "\"OÖ", "XX×", "/OØ", "`UÙ", "'UÚ", "^UÛ", "\"UÜ", "'YÝ",
1772 "HTÞ", "ssß", "`aà", "'aá", "^aâ", "~aã", "\"aä", "*aå", "aeæ", ",cç",
1773 "`eè", "'eé", "^eê", "\"eë", "`iì", "'ií", "^iî", "\"iï", "-dð", "~nñ",
1774 "`oò", "'oó", "^oô", "~oõ", "\"oö", ":-÷", "o/ø", "`uù", "'uú", "^uû",
1775 "\"uü", "'yý", "htþ", "\"yÿ",
1779 static int recurse = 0;
1782 for(c=composetbl; *c; c++) {
1783 if( (*c)[0] == first && (*c)[1] == second)
1785 return (*c)[2] & 0xFF;
1792 nc = check_compose(second, first);
1794 nc = check_compose(toupper(first), toupper(second));
1796 nc = check_compose(toupper(second), toupper(first));
1804 * Translate a WM_(SYS)?KEY(UP|DOWN) message into a string of ASCII
1805 * codes. Returns number of bytes used or zero to drop the message
1806 * or -1 to forward the message to windows.
1808 static int TranslateKey(UINT message, WPARAM wParam, LPARAM lParam,
1809 unsigned char *output) {
1811 int scan, left_alt = 0, key_down, shift_state;
1813 unsigned char * p = output;
1815 static WORD keys[3];
1816 static int compose_state = 0;
1817 static int compose_char = 0;
1818 static WPARAM compose_key = 0;
1820 r = GetKeyboardState(keystate);
1821 if (!r) memset(keystate, 0, sizeof(keystate));
1825 { /* Tell us all about key events */
1826 static BYTE oldstate[256];
1827 static int first = 1;
1830 if(first) memcpy(oldstate, keystate, sizeof(oldstate));
1833 if ((HIWORD(lParam)&(KF_UP|KF_REPEAT))==KF_REPEAT) {
1835 } else if ((HIWORD(lParam)&KF_UP) && scan==(HIWORD(lParam) & 0xFF) ) {
1839 if (wParam >= VK_F1 && wParam <= VK_F20 )
1840 debug(("K_F%d", wParam+1-VK_F1));
1843 case VK_SHIFT: debug(("SHIFT")); break;
1844 case VK_CONTROL: debug(("CTRL")); break;
1845 case VK_MENU: debug(("ALT")); break;
1846 default: debug(("VK_%02x", wParam));
1848 if(message == WM_SYSKEYDOWN || message == WM_SYSKEYUP)
1850 debug((", S%02x", scan=(HIWORD(lParam) & 0xFF) ));
1852 ch = MapVirtualKey(wParam, 2);
1853 if (ch>=' ' && ch<='~') debug((", '%c'", ch));
1854 else if (ch) debug((", $%02x", ch));
1856 if (keys[0]) debug((", KB0=%02x", keys[0]));
1857 if (keys[1]) debug((", KB1=%02x", keys[1]));
1858 if (keys[2]) debug((", KB2=%02x", keys[2]));
1860 if ( (keystate[VK_SHIFT]&0x80)!=0) debug((", S"));
1861 if ( (keystate[VK_CONTROL]&0x80)!=0) debug((", C"));
1862 if ( (HIWORD(lParam)&KF_EXTENDED) ) debug((", E"));
1863 if ( (HIWORD(lParam)&KF_UP) ) debug((", U"));
1866 if ((HIWORD(lParam)&(KF_UP|KF_REPEAT))==KF_REPEAT)
1868 else if ( (HIWORD(lParam)&KF_UP) )
1869 oldstate[wParam&0xFF] ^= 0x80;
1871 oldstate[wParam&0xFF] ^= 0x81;
1873 for(ch=0; ch<256; ch++)
1874 if (oldstate[ch] != keystate[ch])
1875 debug((", M%02x=%02x", ch, keystate[ch]));
1877 memcpy(oldstate, keystate, sizeof(oldstate));
1881 /* Note if AltGr was pressed and if it was used as a compose key */
1882 if (cfg.compose_key) {
1883 if (wParam == VK_MENU && (HIWORD(lParam)&KF_EXTENDED))
1885 keystate[VK_RMENU] = keystate[VK_MENU];
1886 if (!compose_state) compose_key = wParam;
1888 if (wParam == VK_APPS && !compose_state)
1889 compose_key = wParam;
1891 if (wParam == compose_key)
1893 if (compose_state == 0 && (HIWORD(lParam)&(KF_UP|KF_REPEAT))==0)
1895 else if (compose_state == 1 && (HIWORD(lParam)&KF_UP))
1900 else if (compose_state==1 && wParam != VK_CONTROL)
1905 /* Nastyness with NUMLock - Shift-NUMLock is left alone though */
1906 if ( (cfg.funky_type == 3 ||
1907 (cfg.funky_type <= 1 && app_keypad_keys && !cfg.no_applic_k))
1908 && wParam==VK_NUMLOCK && !(keystate[VK_SHIFT]&0x80)) {
1910 wParam = VK_EXECUTE;
1912 /* UnToggle NUMLock */
1913 if ((HIWORD(lParam)&(KF_UP|KF_REPEAT))==0)
1914 keystate[VK_NUMLOCK] ^= 1;
1917 /* And write back the 'adjusted' state */
1918 SetKeyboardState (keystate);
1921 /* Disable Auto repeat if required */
1922 if (repeat_off && (HIWORD(lParam)&(KF_UP|KF_REPEAT))==KF_REPEAT)
1925 if ((HIWORD(lParam)&KF_ALTDOWN) && (keystate[VK_RMENU]&0x80) == 0)
1928 key_down = ((HIWORD(lParam)&KF_UP)==0);
1930 /* Make sure Ctrl-ALT is not the same as AltGr for ToAscii */
1931 if (left_alt && (keystate[VK_CONTROL]&0x80))
1932 keystate[VK_MENU] = 0;
1934 scan = (HIWORD(lParam) & (KF_UP | KF_EXTENDED | 0xFF));
1935 shift_state = ((keystate[VK_SHIFT]&0x80)!=0)
1936 + ((keystate[VK_CONTROL]&0x80)!=0)*2;
1939 * Record that we pressed key so the scroll window can be reset, but
1940 * be careful to avoid Shift-UP/Down
1942 if( wParam != VK_SHIFT && wParam != VK_PRIOR && wParam != VK_NEXT ) {
1946 /* Make sure we're not pasting */
1947 if (key_down) term_nopaste();
1949 if (compose_state>1 && left_alt) compose_state = 0;
1951 /* Sanitize the number pad if not using a PC NumPad */
1952 if( left_alt || (app_keypad_keys && !cfg.no_applic_k
1953 && cfg.funky_type != 2)
1954 || cfg.funky_type == 3 || cfg.nethack_keypad || compose_state )
1956 if ((HIWORD(lParam)&KF_EXTENDED) == 0)
1961 case VK_INSERT: nParam = VK_NUMPAD0; break;
1962 case VK_END: nParam = VK_NUMPAD1; break;
1963 case VK_DOWN: nParam = VK_NUMPAD2; break;
1964 case VK_NEXT: nParam = VK_NUMPAD3; break;
1965 case VK_LEFT: nParam = VK_NUMPAD4; break;
1966 case VK_CLEAR: nParam = VK_NUMPAD5; break;
1967 case VK_RIGHT: nParam = VK_NUMPAD6; break;
1968 case VK_HOME: nParam = VK_NUMPAD7; break;
1969 case VK_UP: nParam = VK_NUMPAD8; break;
1970 case VK_PRIOR: nParam = VK_NUMPAD9; break;
1971 case VK_DELETE: nParam = VK_DECIMAL; break;
1975 if (keystate[VK_NUMLOCK]&1) shift_state |= 1;
1981 /* If a key is pressed and AltGr is not active */
1982 if (key_down && (keystate[VK_RMENU]&0x80) == 0 && !compose_state)
1984 /* Okay, prepare for most alts then ...*/
1985 if (left_alt) *p++ = '\033';
1987 /* Lets see if it's a pattern we know all about ... */
1988 if (wParam == VK_PRIOR && shift_state == 1) {
1989 SendMessage (hwnd, WM_VSCROLL, SB_PAGEUP, 0);
1992 if (wParam == VK_NEXT && shift_state == 1) {
1993 SendMessage (hwnd, WM_VSCROLL, SB_PAGEDOWN, 0);
1996 if (wParam == VK_INSERT && shift_state == 1) {
1997 term_mouse (MB_PASTE, MA_CLICK, 0, 0);
1998 term_mouse (MB_PASTE, MA_RELEASE, 0, 0);
2001 if (left_alt && wParam == VK_F4 && cfg.alt_f4) {
2004 if (left_alt && wParam == VK_SPACE && cfg.alt_space) {
2006 SendMessage (hwnd, WM_SYSCOMMAND, SC_KEYMENU, 0);
2009 /* Control-Numlock for app-keypad mode switch */
2010 if (wParam == VK_PAUSE && shift_state == 2) {
2011 app_keypad_keys ^= 1;
2015 /* Nethack keypad */
2016 if (cfg.nethack_keypad && !left_alt) {
2018 case VK_NUMPAD1: *p++ = shift_state ? 'B': 'b'; return p-output;
2019 case VK_NUMPAD2: *p++ = shift_state ? 'J': 'j'; return p-output;
2020 case VK_NUMPAD3: *p++ = shift_state ? 'N': 'n'; return p-output;
2021 case VK_NUMPAD4: *p++ = shift_state ? 'H': 'h'; return p-output;
2022 case VK_NUMPAD5: *p++ = shift_state ? '.': '.'; return p-output;
2023 case VK_NUMPAD6: *p++ = shift_state ? 'L': 'l'; return p-output;
2024 case VK_NUMPAD7: *p++ = shift_state ? 'Y': 'y'; return p-output;
2025 case VK_NUMPAD8: *p++ = shift_state ? 'K': 'k'; return p-output;
2026 case VK_NUMPAD9: *p++ = shift_state ? 'U': 'u'; return p-output;
2030 /* Application Keypad */
2034 if ( cfg.funky_type == 3 ||
2035 ( cfg.funky_type <= 1 &&
2036 app_keypad_keys && !cfg.no_applic_k)) switch(wParam) {
2037 case VK_EXECUTE: xkey = 'P'; break;
2038 case VK_DIVIDE: xkey = 'Q'; break;
2039 case VK_MULTIPLY:xkey = 'R'; break;
2040 case VK_SUBTRACT:xkey = 'S'; break;
2042 if(app_keypad_keys && !cfg.no_applic_k) switch(wParam) {
2043 case VK_NUMPAD0: xkey = 'p'; break;
2044 case VK_NUMPAD1: xkey = 'q'; break;
2045 case VK_NUMPAD2: xkey = 'r'; break;
2046 case VK_NUMPAD3: xkey = 's'; break;
2047 case VK_NUMPAD4: xkey = 't'; break;
2048 case VK_NUMPAD5: xkey = 'u'; break;
2049 case VK_NUMPAD6: xkey = 'v'; break;
2050 case VK_NUMPAD7: xkey = 'w'; break;
2051 case VK_NUMPAD8: xkey = 'x'; break;
2052 case VK_NUMPAD9: xkey = 'y'; break;
2054 case VK_DECIMAL: xkey = 'n'; break;
2055 case VK_ADD: if(cfg.funky_type==2) {
2056 if(shift_state) xkey = 'l';
2058 } else if(shift_state) xkey = 'm';
2062 case VK_DIVIDE: if(cfg.funky_type==2) xkey = 'o'; break;
2063 case VK_MULTIPLY:if(cfg.funky_type==2) xkey = 'j'; break;
2064 case VK_SUBTRACT:if(cfg.funky_type==2) xkey = 'm'; break;
2067 if (HIWORD(lParam)&KF_EXTENDED)
2075 if (xkey>='P' && xkey<='S')
2076 p += sprintf((char *)p, "\x1B%c", xkey);
2078 p += sprintf((char *)p, "\x1B?%c", xkey);
2081 p += sprintf((char *)p, "\x1BO%c", xkey);
2086 if (wParam == VK_BACK && shift_state == 0 ) /* Backspace */
2088 *p++ = (cfg.bksp_is_delete ? 0x7F : 0x08);
2091 if (wParam == VK_TAB && shift_state == 1 ) /* Shift tab */
2093 *p++ = 0x1B; *p++ = '['; *p++ = 'Z'; return p - output;
2095 if (wParam == VK_SPACE && shift_state == 2 ) /* Ctrl-Space */
2097 *p++ = 0; return p - output;
2099 if (wParam == VK_SPACE && shift_state == 3 ) /* Ctrl-Shift-Space */
2101 *p++ = 160; return p - output;
2103 if (wParam == VK_CANCEL && shift_state == 2 ) /* Ctrl-Break */
2105 *p++ = 3; return p - output;
2107 /* Control-2 to Control-8 are special */
2108 if (shift_state == 2 && wParam >= '2' && wParam <= '8')
2110 *p++ = "\000\033\034\035\036\037\177"[wParam-'2'];
2113 if (shift_state == 2 && wParam == 0xBD) {
2117 if (shift_state == 2 && wParam == 0xDF) {
2121 if (shift_state == 0 && wParam == VK_RETURN && cr_lf_return) {
2122 *p++ = '\r'; *p++ = '\n';
2127 * Next, all the keys that do tilde codes. (ESC '[' nn '~',
2128 * for integer decimal nn.)
2130 * We also deal with the weird ones here. Linux VCs replace F1
2131 * to F5 by ESC [ [ A to ESC [ [ E. rxvt doesn't do _that_, but
2132 * does replace Home and End (1~ and 4~) by ESC [ H and ESC O w
2137 case VK_F1: code = (keystate[VK_SHIFT] & 0x80 ? 23 : 11); break;
2138 case VK_F2: code = (keystate[VK_SHIFT] & 0x80 ? 24 : 12); break;
2139 case VK_F3: code = (keystate[VK_SHIFT] & 0x80 ? 25 : 13); break;
2140 case VK_F4: code = (keystate[VK_SHIFT] & 0x80 ? 26 : 14); break;
2141 case VK_F5: code = (keystate[VK_SHIFT] & 0x80 ? 28 : 15); break;
2142 case VK_F6: code = (keystate[VK_SHIFT] & 0x80 ? 29 : 17); break;
2143 case VK_F7: code = (keystate[VK_SHIFT] & 0x80 ? 31 : 18); break;
2144 case VK_F8: code = (keystate[VK_SHIFT] & 0x80 ? 32 : 19); break;
2145 case VK_F9: code = (keystate[VK_SHIFT] & 0x80 ? 33 : 20); break;
2146 case VK_F10: code = (keystate[VK_SHIFT] & 0x80 ? 34 : 21); break;
2147 case VK_F11: code = 23; break;
2148 case VK_F12: code = 24; break;
2149 case VK_F13: code = 25; break;
2150 case VK_F14: code = 26; break;
2151 case VK_F15: code = 28; break;
2152 case VK_F16: code = 29; break;
2153 case VK_F17: code = 31; break;
2154 case VK_F18: code = 32; break;
2155 case VK_F19: code = 33; break;
2156 case VK_F20: code = 34; break;
2157 case VK_HOME: code = 1; break;
2158 case VK_INSERT: code = 2; break;
2159 case VK_DELETE: code = 3; break;
2160 case VK_END: code = 4; break;
2161 case VK_PRIOR: code = 5; break;
2162 case VK_NEXT: code = 6; break;
2164 /* Reorder edit keys to physical order */
2165 if (cfg.funky_type == 3 && code <= 6 ) code = "\0\2\1\4\5\3\6"[code];
2167 if (cfg.funky_type == 1 && code >= 11 && code <= 15) {
2168 p += sprintf((char *)p, "\x1B[[%c", code + 'A' - 11);
2171 if (cfg.funky_type == 2 && code >= 11 && code <= 14) {
2173 p += sprintf((char *)p, "\x1B%c", code + 'P' - 11);
2175 p += sprintf((char *)p, "\x1BO%c", code + 'P' - 11);
2178 if (cfg.rxvt_homeend && (code == 1 || code == 4)) {
2179 p += sprintf((char *)p, code == 1 ? "\x1B[H" : "\x1BOw");
2183 p += sprintf((char *)p, "\x1B[%d~", code);
2188 * Now the remaining keys (arrows and Keypad 5. Keypad 5 for
2189 * some reason seems to send VK_CLEAR to Windows...).
2194 case VK_UP: xkey = 'A'; break;
2195 case VK_DOWN: xkey = 'B'; break;
2196 case VK_RIGHT: xkey = 'C'; break;
2197 case VK_LEFT: xkey = 'D'; break;
2198 case VK_CLEAR: xkey = 'G'; break;
2203 p += sprintf((char *)p, "\x1B%c", xkey);
2204 else if (app_cursor_keys && !cfg.no_applic_c)
2205 p += sprintf((char *)p, "\x1BO%c", xkey);
2207 p += sprintf((char *)p, "\x1B[%c", xkey);
2213 * Finally, deal with Return ourselves. (Win95 seems to
2214 * foul it up when Alt is pressed, for some reason.)
2216 if (wParam == VK_RETURN) /* Return */
2223 /* Okay we've done everything interesting; let windows deal with
2224 * the boring stuff */
2226 BOOL capsOn=keystate[VK_CAPITAL] !=0;
2228 /* helg: clear CAPS LOCK state if caps lock switches to cyrillic */
2229 if(cfg.xlat_capslockcyr)
2230 keystate[VK_CAPITAL] = 0;
2232 r = ToAscii (wParam, scan, keystate, keys, 0);
2238 unsigned char ch = (unsigned char)keys[i];
2240 if (compose_state==2 && (ch&0x80) == 0 && ch>' ') {
2245 if (compose_state==3 && (ch&0x80) == 0 && ch>' ') {
2249 if ((nc=check_compose(compose_char,ch)) == -1)
2251 MessageBeep(MB_ICONHAND);
2254 *p++ = xlat_kbd2tty((unsigned char)nc);
2260 if( left_alt && key_down ) *p++ = '\033';
2266 ch = xlat_latkbd2win(ch);
2267 *p++ = xlat_kbd2tty(ch);
2271 /* This is so the ALT-Numpad and dead keys work correctly. */
2278 /* This stops ALT press-release doing a 'COMMAND MENU' function */
2279 if (!cfg.alt_only) {
2280 if (message == WM_SYSKEYUP && wParam == VK_MENU)
2287 void set_title (char *title) {
2288 sfree (window_name);
2289 window_name = smalloc(1+strlen(title));
2290 strcpy (window_name, title);
2291 if (cfg.win_name_always || !IsIconic(hwnd))
2292 SetWindowText (hwnd, title);
2295 void set_icon (char *title) {
2297 icon_name = smalloc(1+strlen(title));
2298 strcpy (icon_name, title);
2299 if (!cfg.win_name_always && IsIconic(hwnd))
2300 SetWindowText (hwnd, title);
2303 void set_sbar (int total, int start, int page) {
2306 if (!cfg.scrollbar) return;
2308 si.cbSize = sizeof(si);
2309 si.fMask = SIF_ALL | SIF_DISABLENOSCROLL;
2311 si.nMax = total - 1;
2315 SetScrollInfo (hwnd, SB_VERT, &si, TRUE);
2318 Context get_ctx(void) {
2323 SelectPalette (hdc, pal, FALSE);
2329 void free_ctx (Context ctx) {
2330 SelectPalette (ctx, GetStockObject (DEFAULT_PALETTE), FALSE);
2331 ReleaseDC (hwnd, ctx);
2334 static void real_palette_set (int n, int r, int g, int b) {
2336 logpal->palPalEntry[n].peRed = r;
2337 logpal->palPalEntry[n].peGreen = g;
2338 logpal->palPalEntry[n].peBlue = b;
2339 logpal->palPalEntry[n].peFlags = PC_NOCOLLAPSE;
2340 colours[n] = PALETTERGB(r, g, b);
2341 SetPaletteEntries (pal, 0, NCOLOURS, logpal->palPalEntry);
2343 colours[n] = RGB(r, g, b);
2346 void palette_set (int n, int r, int g, int b) {
2347 static const int first[21] = {
2348 0, 2, 4, 6, 8, 10, 12, 14,
2349 1, 3, 5, 7, 9, 11, 13, 15,
2352 real_palette_set (first[n], r, g, b);
2354 real_palette_set (first[n]+1, r, g, b);
2356 HDC hdc = get_ctx();
2357 UnrealizeObject (pal);
2358 RealizePalette (hdc);
2363 void palette_reset (void) {
2366 for (i = 0; i < NCOLOURS; i++) {
2368 logpal->palPalEntry[i].peRed = defpal[i].rgbtRed;
2369 logpal->palPalEntry[i].peGreen = defpal[i].rgbtGreen;
2370 logpal->palPalEntry[i].peBlue = defpal[i].rgbtBlue;
2371 logpal->palPalEntry[i].peFlags = 0;
2372 colours[i] = PALETTERGB(defpal[i].rgbtRed,
2373 defpal[i].rgbtGreen,
2374 defpal[i].rgbtBlue);
2376 colours[i] = RGB(defpal[i].rgbtRed,
2377 defpal[i].rgbtGreen,
2378 defpal[i].rgbtBlue);
2383 SetPaletteEntries (pal, 0, NCOLOURS, logpal->palPalEntry);
2385 RealizePalette (hdc);
2390 void write_clip (void *data, int len, int must_deselect) {
2394 clipdata = GlobalAlloc (GMEM_DDESHARE | GMEM_MOVEABLE, len + 1);
2397 lock = GlobalLock (clipdata);
2400 memcpy (lock, data, len);
2401 ((unsigned char *) lock) [len] = 0;
2402 GlobalUnlock (clipdata);
2405 SendMessage (hwnd, WM_IGNORE_CLIP, TRUE, 0);
2407 if (OpenClipboard (hwnd)) {
2409 SetClipboardData (CF_TEXT, clipdata);
2412 GlobalFree (clipdata);
2415 SendMessage (hwnd, WM_IGNORE_CLIP, FALSE, 0);
2418 void get_clip (void **p, int *len) {
2419 static HGLOBAL clipdata = NULL;
2423 GlobalUnlock (clipdata);
2427 if (OpenClipboard (NULL)) {
2428 clipdata = GetClipboardData (CF_TEXT);
2431 *p = GlobalLock (clipdata);
2445 * Move `lines' lines from position `from' to position `to' in the
2448 void optimised_move (int to, int from, int lines) {
2452 min = (to < from ? to : from);
2453 max = to + from - min;
2455 r.left = 0; r.right = cols * font_width;
2456 r.top = min * font_height; r.bottom = (max+lines) * font_height;
2457 ScrollWindow (hwnd, 0, (to - from) * font_height, &r, &r);
2461 * Print a message box and perform a fatal exit.
2463 void fatalbox(char *fmt, ...) {
2468 vsprintf(stuff, fmt, ap);
2470 MessageBox(hwnd, stuff, "PuTTY Fatal Error", MB_ICONERROR | MB_OK);
2477 void beep(int errorbeep) {
2478 static long last_beep = 0;
2479 long now, beep_diff;
2481 now = GetTickCount();
2482 beep_diff = now-last_beep;
2484 /* Make sure we only respond to one beep per packet or so */
2485 if (beep_diff>=0 && beep_diff<50)
2489 MessageBeep(MB_ICONHAND);
2493 last_beep = GetTickCount();