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 Ldisc *real_ldisc;
106 static int compose_state = 0;
108 void begin_session(void) {
112 int WINAPI WinMain(HINSTANCE inst, HINSTANCE prev, LPSTR cmdline, int show) {
113 static char appname[] = "PuTTY";
118 int guess_width, guess_height;
121 flags = FLAG_VERBOSE | FLAG_INTERACTIVE;
123 winsock_ver = MAKEWORD(1, 1);
124 if (WSAStartup(winsock_ver, &wsadata)) {
125 MessageBox(NULL, "Unable to initialise WinSock", "WinSock Error",
126 MB_OK | MB_ICONEXCLAMATION);
129 if (LOBYTE(wsadata.wVersion) != 1 || HIBYTE(wsadata.wVersion) != 1) {
130 MessageBox(NULL, "WinSock version is incompatible with 1.1",
131 "WinSock Error", MB_OK | MB_ICONEXCLAMATION);
135 /* WISHLIST: maybe allow config tweaking even if winsock not present? */
138 InitCommonControls();
140 /* Ensure a Maximize setting in Explorer doesn't maximise the
145 * Process the command line.
150 default_protocol = DEFAULT_PROTOCOL;
151 default_port = DEFAULT_PORT;
153 do_defaults(NULL, &cfg);
156 while (*p && isspace(*p)) p++;
159 * Process command line options first. Yes, this can be
160 * done better, and it will be as soon as I have the
164 char *q = p + strcspn(p, " \t");
167 tolower(p[0]) == 's' &&
168 tolower(p[1]) == 's' &&
169 tolower(p[2]) == 'h') {
170 default_protocol = cfg.protocol = PROT_SSH;
171 default_port = cfg.port = 22;
172 } else if (q == p + 3 &&
173 tolower(p[0]) == 'l' &&
174 tolower(p[1]) == 'o' &&
175 tolower(p[2]) == 'g') {
176 logfile = "putty.log";
177 } else if (q == p + 7 &&
178 tolower(p[0]) == 'c' &&
179 tolower(p[1]) == 'l' &&
180 tolower(p[2]) == 'e' &&
181 tolower(p[3]) == 'a' &&
182 tolower(p[4]) == 'n' &&
183 tolower(p[5]) == 'u' &&
184 tolower(p[6]) == 'p') {
186 * `putty -cleanup'. Remove all registry entries
187 * associated with PuTTY, and also find and delete
188 * the random seed file.
191 "This procedure will remove ALL Registry\n"
192 "entries associated with PuTTY, and will\n"
193 "also remove the PuTTY random seed file.\n"
195 "THIS PROCESS WILL DESTROY YOUR SAVED\n"
196 "SESSIONS. Are you really sure you want\n"
199 MB_YESNO | MB_ICONWARNING) == IDYES) {
204 p = q + strspn(q, " \t");
208 * An initial @ means to activate a saved session.
212 while (i > 1 && isspace(p[i-1]))
215 do_defaults (p+1, &cfg);
216 if (!*cfg.host && !do_config()) {
220 } else if (*p == '&') {
222 * An initial & means we've been given a command line
223 * containing the hex value of a HANDLE for a file
224 * mapping object, which we must then extract as a
229 if (sscanf(p+1, "%p", &filemap) == 1 &&
230 (cp = MapViewOfFile(filemap, FILE_MAP_READ,
231 0, 0, sizeof(Config))) != NULL) {
234 CloseHandle(filemap);
235 } else if (!do_config()) {
242 * If the hostname starts with "telnet:", set the
243 * protocol to Telnet and process the string as a
246 if (!strncmp(q, "telnet:", 7)) {
250 if (q[0] == '/' && q[1] == '/')
252 cfg.protocol = PROT_TELNET;
254 while (*p && *p != ':' && *p != '/') p++;
262 strncpy (cfg.host, q, sizeof(cfg.host)-1);
263 cfg.host[sizeof(cfg.host)-1] = '\0';
265 while (*p && !isspace(*p)) p++;
268 strncpy (cfg.host, q, sizeof(cfg.host)-1);
269 cfg.host[sizeof(cfg.host)-1] = '\0';
270 while (*p && isspace(*p)) p++;
283 /* See if host is of the form user@host */
284 if (cfg.host[0] != '\0') {
285 char *atsign = strchr(cfg.host, '@');
286 /* Make sure we're not overflowing the user field */
288 if (atsign-cfg.host < sizeof cfg.username) {
289 strncpy (cfg.username, cfg.host, atsign-cfg.host);
290 cfg.username[atsign-cfg.host] = '\0';
292 memmove(cfg.host, atsign+1, 1+strlen(atsign+1));
298 * Select protocol. This is farmed out into a table in a
299 * separate file to enable an ssh-free variant.
304 for (i = 0; backends[i].backend != NULL; i++)
305 if (backends[i].protocol == cfg.protocol) {
306 back = backends[i].backend;
310 MessageBox(NULL, "Unsupported protocol number found",
311 "PuTTY Internal Error", MB_OK | MB_ICONEXCLAMATION);
317 /* Check for invalid Port number (i.e. zero) */
319 MessageBox(NULL, "Invalid Port Number",
320 "PuTTY Internal Error", MB_OK |MB_ICONEXCLAMATION);
325 real_ldisc = (cfg.ldisc_term ? &ldisc_term : &ldisc_simple);
326 /* To start with, we use the simple line discipline, so we can
327 * type passwords etc without fear of them being echoed... */
328 ldisc = &ldisc_simple;
332 wndclass.lpfnWndProc = WndProc;
333 wndclass.cbClsExtra = 0;
334 wndclass.cbWndExtra = 0;
335 wndclass.hInstance = inst;
336 wndclass.hIcon = LoadIcon (inst,
337 MAKEINTRESOURCE(IDI_MAINICON));
338 wndclass.hCursor = LoadCursor (NULL, IDC_IBEAM);
339 wndclass.hbrBackground = GetStockObject (BLACK_BRUSH);
340 wndclass.lpszMenuName = NULL;
341 wndclass.lpszClassName = appname;
343 RegisterClass (&wndclass);
348 savelines = cfg.savelines;
354 * Guess some defaults for the window size. This all gets
355 * updated later, so we don't really care too much. However, we
356 * do want the font width/height guesses to correspond to a
357 * large font rather than a small one...
364 term_size (cfg.height, cfg.width, cfg.savelines);
365 guess_width = extra_width + font_width * cols;
366 guess_height = extra_height + font_height * rows;
369 HWND w = GetDesktopWindow();
370 GetWindowRect (w, &r);
371 if (guess_width > r.right - r.left)
372 guess_width = r.right - r.left;
373 if (guess_height > r.bottom - r.top)
374 guess_height = r.bottom - r.top;
378 int winmode = WS_OVERLAPPEDWINDOW|WS_VSCROLL;
380 if (!cfg.scrollbar) winmode &= ~(WS_VSCROLL);
381 if (cfg.locksize) winmode &= ~(WS_THICKFRAME|WS_MAXIMIZEBOX);
382 if (cfg.alwaysontop) exwinmode = WS_EX_TOPMOST;
383 hwnd = CreateWindowEx (exwinmode, appname, appname,
384 winmode, CW_USEDEFAULT, CW_USEDEFAULT,
385 guess_width, guess_height,
386 NULL, NULL, inst, NULL);
390 * Initialise the fonts, simultaneously correcting the guesses
391 * for font_{width,height}.
393 bold_mode = cfg.bold_colour ? BOLD_COLOURS : BOLD_FONT;
398 * Correct the guesses for extra_{width,height}.
402 GetWindowRect (hwnd, &wr);
403 GetClientRect (hwnd, &cr);
404 extra_width = wr.right - wr.left - cr.right + cr.left;
405 extra_height = wr.bottom - wr.top - cr.bottom + cr.top;
409 * Resize the window, now we know what size we _really_ want it
412 guess_width = extra_width + font_width * cols;
413 guess_height = extra_height + font_height * rows;
414 SendMessage (hwnd, WM_IGNORE_SIZE, 0, 0);
415 SetWindowPos (hwnd, NULL, 0, 0, guess_width, guess_height,
416 SWP_NOMOVE | SWP_NOREDRAW | SWP_NOZORDER);
419 * Set up a caret bitmap, with no content.
423 int size = (font_width+15)/16 * 2 * font_height;
424 bits = smalloc(size);
425 memset(bits, 0, size);
426 caretbm = CreateBitmap(font_width, font_height, 1, 1, bits);
431 * Initialise the scroll bar.
436 si.cbSize = sizeof(si);
437 si.fMask = SIF_ALL | SIF_DISABLENOSCROLL;
442 SetScrollInfo (hwnd, SB_VERT, &si, FALSE);
446 * Start up the telnet connection.
450 char msg[1024], *title;
453 error = back->init (cfg.host, cfg.port, &realhost);
455 sprintf(msg, "Unable to open connection:\n%s", error);
456 MessageBox(NULL, msg, "PuTTY Error", MB_ICONERROR | MB_OK);
459 window_name = icon_name = NULL;
461 title = cfg.wintitle;
463 sprintf(msg, "%s - PuTTY", realhost);
470 session_closed = FALSE;
473 * Set up the input and output buffers.
476 outbuf_reap = outbuf_head = 0;
479 * Prepare the mouse handler.
481 lastact = MA_NOTHING;
482 lastbtn = MB_NOTHING;
483 dbltime = GetDoubleClickTime();
486 * Set up the session-control options on the system menu.
489 HMENU m = GetSystemMenu (hwnd, FALSE);
493 AppendMenu (m, MF_SEPARATOR, 0, 0);
494 if (cfg.protocol == PROT_TELNET) {
496 AppendMenu (p, MF_ENABLED, IDM_TEL_AYT, "Are You There");
497 AppendMenu (p, MF_ENABLED, IDM_TEL_BRK, "Break");
498 AppendMenu (p, MF_ENABLED, IDM_TEL_SYNCH, "Synch");
499 AppendMenu (p, MF_SEPARATOR, 0, 0);
500 AppendMenu (p, MF_ENABLED, IDM_TEL_EC, "Erase Character");
501 AppendMenu (p, MF_ENABLED, IDM_TEL_EL, "Erase Line");
502 AppendMenu (p, MF_ENABLED, IDM_TEL_GA, "Go Ahead");
503 AppendMenu (p, MF_ENABLED, IDM_TEL_NOP, "No Operation");
504 AppendMenu (p, MF_SEPARATOR, 0, 0);
505 AppendMenu (p, MF_ENABLED, IDM_TEL_ABORT, "Abort Process");
506 AppendMenu (p, MF_ENABLED, IDM_TEL_AO, "Abort Output");
507 AppendMenu (p, MF_ENABLED, IDM_TEL_IP, "Interrupt Process");
508 AppendMenu (p, MF_ENABLED, IDM_TEL_SUSP, "Suspend Process");
509 AppendMenu (p, MF_SEPARATOR, 0, 0);
510 AppendMenu (p, MF_ENABLED, IDM_TEL_EOR, "End Of Record");
511 AppendMenu (p, MF_ENABLED, IDM_TEL_EOF, "End Of File");
512 AppendMenu (m, MF_POPUP | MF_ENABLED, (UINT) p, "Telnet Command");
513 AppendMenu (m, MF_SEPARATOR, 0, 0);
515 AppendMenu (m, MF_ENABLED, IDM_SHOWLOG, "&Event Log");
516 AppendMenu (m, MF_SEPARATOR, 0, 0);
517 AppendMenu (m, MF_ENABLED, IDM_NEWSESS, "Ne&w Session...");
518 AppendMenu (m, MF_ENABLED, IDM_DUPSESS, "&Duplicate Session");
521 for (i = 1 ; i < ((nsessions < 256) ? nsessions : 256) ; i++)
522 AppendMenu (s, MF_ENABLED, IDM_SAVED_MIN + (16 * i) , sessions[i]);
523 AppendMenu (m, MF_POPUP | MF_ENABLED, (UINT) s, "Sa&ved Sessions");
524 AppendMenu (m, MF_ENABLED, IDM_RECONF, "Chan&ge Settings...");
525 AppendMenu (m, MF_SEPARATOR, 0, 0);
526 AppendMenu (m, MF_ENABLED, IDM_COPYALL, "C&opy All to Clipboard");
527 AppendMenu (m, MF_ENABLED, IDM_CLRSB, "C&lear Scrollback");
528 AppendMenu (m, MF_ENABLED, IDM_RESET, "Rese&t Terminal");
529 AppendMenu (m, MF_SEPARATOR, 0, 0);
530 AppendMenu (m, MF_ENABLED, IDM_ABOUT, "&About PuTTY");
534 * Finally show the window!
536 ShowWindow (hwnd, show);
539 * Set the palette up.
545 has_focus = (GetForegroundWindow() == hwnd);
548 if (GetMessage (&msg, NULL, 0, 0) == 1)
550 int timer_id = 0, long_timer = 0;
552 while (msg.message != WM_QUIT) {
553 /* Sometimes DispatchMessage calls routines that use their own
554 * GetMessage loop, setup this timer so we get some control back.
556 * Also call term_update() from the timer so that if the host
557 * is sending data flat out we still do redraws.
559 if(timer_id && long_timer) {
560 KillTimer(hwnd, timer_id);
561 long_timer = timer_id = 0;
564 timer_id = SetTimer(hwnd, 1, 20, NULL);
565 DispatchMessage (&msg);
567 /* Make sure we blink everything that needs it. */
570 /* Send the paste buffer if there's anything to send */
573 /* If there's nothing new in the queue then we can do everything
574 * we've delayed, reading the socket, writing, and repainting
577 if (PeekMessage (&msg, NULL, 0, 0, PM_REMOVE))
580 if (pending_netevent) {
581 enact_pending_netevent();
583 /* Force the cursor blink on */
586 if (PeekMessage (&msg, NULL, 0, 0, PM_REMOVE))
590 /* Okay there is now nothing to do so we make sure the screen is
591 * completely up to date then tell windows to call us in a little
595 KillTimer(hwnd, timer_id);
604 timer_id = SetTimer(hwnd, 1, 59500, NULL);
606 timer_id = SetTimer(hwnd, 1, 100, NULL);
609 /* There's no point rescanning everything in the message queue
610 * so we do an apperently unneccesary wait here
613 if (GetMessage (&msg, NULL, 0, 0) != 1)
625 DeleteObject(fonts[i]);
632 if (cfg.protocol == PROT_SSH) {
643 * Set up, or shut down, an AsyncSelect. Called from winnet.c.
645 char *do_select(SOCKET skt, int startup) {
649 events = FD_READ | FD_WRITE | FD_OOB | FD_CLOSE;
654 return "do_select(): internal error (hwnd==NULL)";
655 if (WSAAsyncSelect (skt, hwnd, msg, events) == SOCKET_ERROR) {
656 switch (WSAGetLastError()) {
657 case WSAENETDOWN: return "Network is down";
658 default: return "WSAAsyncSelect(): unknown error";
665 * Print a message box and close the connection.
667 void connection_fatal(char *fmt, ...) {
672 vsprintf(stuff, fmt, ap);
674 MessageBox(hwnd, stuff, "PuTTY Fatal Error", MB_ICONERROR | MB_OK);
675 if (cfg.close_on_exit)
678 session_closed = TRUE;
679 SetWindowText (hwnd, "PuTTY (inactive)");
684 * Actually do the job requested by a WM_NETEVENT
686 static void enact_pending_netevent(void) {
687 static int reentering = 0;
688 extern int select_result(WPARAM, LPARAM);
692 return; /* don't unpend the pending */
694 pending_netevent = FALSE;
697 ret = select_result (pend_netevent_wParam, pend_netevent_lParam);
701 if (cfg.close_on_exit)
704 session_closed = TRUE;
705 MessageBox(hwnd, "Connection closed by remote host",
706 "PuTTY", MB_OK | MB_ICONINFORMATION);
707 SetWindowText (hwnd, "PuTTY (inactive)");
713 * Copy the colour palette from the configuration data into defpal.
714 * This is non-trivial because the colour indices are different.
716 static void cfgtopalette(void) {
718 static const int ww[] = {
719 6, 7, 8, 9, 10, 11, 12, 13,
720 14, 15, 16, 17, 18, 19, 20, 21,
721 0, 1, 2, 3, 4, 4, 5, 5
724 for (i=0; i<24; i++) {
726 defpal[i].rgbtRed = cfg.colours[w][0];
727 defpal[i].rgbtGreen = cfg.colours[w][1];
728 defpal[i].rgbtBlue = cfg.colours[w][2];
733 * Set up the colour palette.
735 static void init_palette(void) {
737 HDC hdc = GetDC (hwnd);
739 if (cfg.try_palette &&
740 GetDeviceCaps (hdc, RASTERCAPS) & RC_PALETTE) {
741 logpal = smalloc(sizeof(*logpal)
742 - sizeof(logpal->palPalEntry)
743 + NCOLOURS * sizeof(PALETTEENTRY));
744 logpal->palVersion = 0x300;
745 logpal->palNumEntries = NCOLOURS;
746 for (i = 0; i < NCOLOURS; i++) {
747 logpal->palPalEntry[i].peRed = defpal[i].rgbtRed;
748 logpal->palPalEntry[i].peGreen = defpal[i].rgbtGreen;
749 logpal->palPalEntry[i].peBlue = defpal[i].rgbtBlue;
750 logpal->palPalEntry[i].peFlags = PC_NOCOLLAPSE;
752 pal = CreatePalette (logpal);
754 SelectPalette (hdc, pal, FALSE);
755 RealizePalette (hdc);
756 SelectPalette (hdc, GetStockObject (DEFAULT_PALETTE),
760 ReleaseDC (hwnd, hdc);
763 for (i=0; i<NCOLOURS; i++)
764 colours[i] = PALETTERGB(defpal[i].rgbtRed,
768 for(i=0; i<NCOLOURS; i++)
769 colours[i] = RGB(defpal[i].rgbtRed,
775 * Initialise all the fonts we will need. There may be as many as
776 * eight or as few as one. We also:
778 * - check the font width and height, correcting our guesses if
781 * - verify that the bold font is the same width as the ordinary
782 * one, and engage shadow bolding if not.
784 * - verify that the underlined font is the same width as the
785 * ordinary one (manual underlining by means of line drawing can
786 * be done in a pinch).
788 static void init_fonts(int pick_width) {
793 int fw_dontcare, fw_bold;
802 if (cfg.fontisbold) {
803 fw_dontcare = FW_BOLD;
806 fw_dontcare = FW_DONTCARE;
812 font_height = cfg.fontheight;
813 font_width = pick_width;
816 fonts[i] = CreateFont (font_height, font_width, 0, 0, w, FALSE, u, FALSE, \
817 c, OUT_DEFAULT_PRECIS, \
818 CLIP_DEFAULT_PRECIS, DEFAULT_QUALITY, \
819 FIXED_PITCH | FF_DONTCARE, cfg.font)
821 if (cfg.vtmode != VT_OEMONLY) {
822 f(FONT_NORMAL, cfg.fontcharset, fw_dontcare, FALSE);
824 SelectObject (hdc, fonts[FONT_NORMAL]);
825 GetTextMetrics(hdc, &tm);
826 font_height = tm.tmHeight;
827 font_width = tm.tmAveCharWidth;
829 f(FONT_UNDERLINE, cfg.fontcharset, fw_dontcare, TRUE);
832 * Some fonts, e.g. 9-pt Courier, draw their underlines
833 * outside their character cell. We successfully prevent
834 * screen corruption by clipping the text output, but then
835 * we lose the underline completely. Here we try to work
836 * out whether this is such a font, and if it is, we set a
837 * flag that causes underlines to be drawn by hand.
839 * Having tried other more sophisticated approaches (such
840 * as examining the TEXTMETRIC structure or requesting the
841 * height of a string), I think we'll do this the brute
842 * force way: we create a small bitmap, draw an underlined
843 * space on it, and test to see whether any pixels are
844 * foreground-coloured. (Since we expect the underline to
845 * go all the way across the character cell, we only search
846 * down a single column of the bitmap, half way across.)
850 HBITMAP und_bm, und_oldbm;
854 und_dc = CreateCompatibleDC(hdc);
855 und_bm = CreateCompatibleBitmap(hdc, font_width, font_height);
856 und_oldbm = SelectObject(und_dc, und_bm);
857 SelectObject(und_dc, fonts[FONT_UNDERLINE]);
858 SetTextAlign(und_dc, TA_TOP | TA_LEFT | TA_NOUPDATECP);
859 SetTextColor (und_dc, RGB(255,255,255));
860 SetBkColor (und_dc, RGB(0,0,0));
861 SetBkMode (und_dc, OPAQUE);
862 ExtTextOut (und_dc, 0, 0, ETO_OPAQUE, NULL, " ", 1, NULL);
864 for (i = 0; i < font_height; i++) {
865 c = GetPixel(und_dc, font_width/2, i);
869 SelectObject(und_dc, und_oldbm);
870 DeleteObject(und_bm);
872 font_needs_hand_underlining = !gotit;
875 if (bold_mode == BOLD_FONT) {
876 f(FONT_BOLD, cfg.fontcharset, fw_bold, FALSE);
877 f(FONT_BOLDUND, cfg.fontcharset, fw_bold, TRUE);
880 if (cfg.vtmode == VT_OEMANSI) {
881 f(FONT_OEM, OEM_CHARSET, fw_dontcare, FALSE);
882 f(FONT_OEMUND, OEM_CHARSET, fw_dontcare, TRUE);
884 if (bold_mode == BOLD_FONT) {
885 f(FONT_OEMBOLD, OEM_CHARSET, fw_bold, FALSE);
886 f(FONT_OEMBOLDUND, OEM_CHARSET, fw_bold, TRUE);
892 f(FONT_OEM, cfg.fontcharset, fw_dontcare, FALSE);
894 SelectObject (hdc, fonts[FONT_OEM]);
895 GetTextMetrics(hdc, &tm);
896 font_height = tm.tmHeight;
897 font_width = tm.tmAveCharWidth;
899 f(FONT_OEMUND, cfg.fontcharset, fw_dontcare, TRUE);
901 if (bold_mode == BOLD_FONT) {
902 f(FONT_BOLD, cfg.fontcharset, fw_bold, FALSE);
903 f(FONT_BOLDUND, cfg.fontcharset, fw_bold, TRUE);
908 descent = tm.tmAscent + 1;
909 if (descent >= font_height)
910 descent = font_height - 1;
911 firstchar = tm.tmFirstChar;
913 for (i=0; i<8; i++) {
915 if (SelectObject (hdc, fonts[i]) &&
916 GetTextMetrics(hdc, &tm) )
917 fsize[i] = tm.tmAveCharWidth + 256 * tm.tmHeight;
923 ReleaseDC (hwnd, hdc);
925 /* ... This is wrong in OEM only mode */
926 if (fsize[FONT_UNDERLINE] != fsize[FONT_NORMAL] ||
927 (bold_mode == BOLD_FONT &&
928 fsize[FONT_BOLDUND] != fsize[FONT_BOLD])) {
930 DeleteObject (fonts[FONT_UNDERLINE]);
931 if (bold_mode == BOLD_FONT)
932 DeleteObject (fonts[FONT_BOLDUND]);
935 if (bold_mode == BOLD_FONT &&
936 fsize[FONT_BOLD] != fsize[FONT_NORMAL]) {
937 bold_mode = BOLD_SHADOW;
938 DeleteObject (fonts[FONT_BOLD]);
939 if (und_mode == UND_FONT)
940 DeleteObject (fonts[FONT_BOLDUND]);
944 /* With the fascist font painting it doesn't matter if the linedraw font
945 * isn't exactly the right size anymore so we don't have to check this.
947 if (cfg.vtmode == VT_OEMANSI && fsize[FONT_OEM] != fsize[FONT_NORMAL] ) {
948 if( cfg.fontcharset == OEM_CHARSET )
950 MessageBox(NULL, "The OEM and ANSI versions of this font are\n"
951 "different sizes. Using OEM-only mode instead",
952 "Font Size Mismatch", MB_ICONINFORMATION | MB_OK);
953 cfg.vtmode = VT_OEMONLY;
955 else if( firstchar < ' ' )
957 MessageBox(NULL, "The OEM and ANSI versions of this font are\n"
958 "different sizes. Using XTerm mode instead",
959 "Font Size Mismatch", MB_ICONINFORMATION | MB_OK);
960 cfg.vtmode = VT_XWINDOWS;
964 MessageBox(NULL, "The OEM and ANSI versions of this font are\n"
965 "different sizes. Using ISO8859-1 mode instead",
966 "Font Size Mismatch", MB_ICONINFORMATION | MB_OK);
967 cfg.vtmode = VT_POORMAN;
972 DeleteObject (fonts[i]);
978 void request_resize (int w, int h, int refont) {
981 /* If the window is maximized supress resizing attempts */
982 if(IsZoomed(hwnd)) return;
985 /* Don't do this in OEMANSI, you may get disable messages */
986 if (refont && w != cols && (cols==80 || cols==132)
987 && cfg.vtmode != VT_OEMANSI)
989 if (refont && w != cols && (cols==80 || cols==132))
992 /* If font width too big for screen should we shrink the font more ? */
994 font_width = ((font_width*cols+w/2)/w);
1001 DeleteObject(fonts[i]);
1003 bold_mode = cfg.bold_colour ? BOLD_COLOURS : BOLD_FONT;
1004 und_mode = UND_FONT;
1005 init_fonts(font_width);
1009 static int first_time = 1;
1015 /* Get the size of the screen */
1016 if (GetClientRect(GetDesktopWindow(),&ss))
1017 /* first_time = 0 */;
1018 else { first_time = 2; break; }
1020 /* Make sure the values are sane */
1021 width = (ss.right-ss.left-extra_width ) / font_width;
1022 height = (ss.bottom-ss.top-extra_height ) / font_height;
1024 if (w>width) w=width;
1025 if (h>height) h=height;
1031 width = extra_width + font_width * w;
1032 height = extra_height + font_height * h;
1034 SetWindowPos (hwnd, NULL, 0, 0, width, height,
1035 SWP_NOACTIVATE | SWP_NOCOPYBITS |
1036 SWP_NOMOVE | SWP_NOZORDER);
1039 static void click (Mouse_Button b, int x, int y) {
1040 int thistime = GetMessageTime();
1042 if (lastbtn == b && thistime - lasttime < dbltime) {
1043 lastact = (lastact == MA_CLICK ? MA_2CLK :
1044 lastact == MA_2CLK ? MA_3CLK :
1045 lastact == MA_3CLK ? MA_CLICK : MA_NOTHING);
1050 if (lastact != MA_NOTHING)
1051 term_mouse (b, lastact, x, y);
1052 lasttime = thistime;
1055 static LRESULT CALLBACK WndProc (HWND hwnd, UINT message,
1056 WPARAM wParam, LPARAM lParam) {
1058 static int ignore_size = FALSE;
1059 static int ignore_clip = FALSE;
1060 static int just_reconfigged = FALSE;
1061 static int resizing = FALSE;
1065 if (pending_netevent)
1066 enact_pending_netevent();
1073 if (cfg.ping_interval > 0)
1077 if (now-last_movement > cfg.ping_interval * 60 - 10)
1079 back->special(TS_PING);
1080 last_movement = now;
1087 if (!cfg.warn_on_close || session_closed ||
1088 MessageBox(hwnd, "Are you sure you want to close this session?",
1089 "PuTTY Exit Confirmation",
1090 MB_ICONWARNING | MB_OKCANCEL) == IDOK)
1091 DestroyWindow(hwnd);
1094 PostQuitMessage (0);
1097 switch (wParam & ~0xF) { /* low 4 bits reserved to Windows */
1109 PROCESS_INFORMATION pi;
1110 HANDLE filemap = NULL;
1112 if (wParam == IDM_DUPSESS) {
1114 * Allocate a file-mapping memory chunk for the
1117 SECURITY_ATTRIBUTES sa;
1120 sa.nLength = sizeof(sa);
1121 sa.lpSecurityDescriptor = NULL;
1122 sa.bInheritHandle = TRUE;
1123 filemap = CreateFileMapping((HANDLE)0xFFFFFFFF,
1130 p = (Config *)MapViewOfFile(filemap,
1132 0, 0, sizeof(Config));
1134 *p = cfg; /* structure copy */
1138 sprintf(c, "putty &%p", filemap);
1140 } else if (wParam == IDM_SAVEDSESS) {
1141 char *session = sessions[(lParam - IDM_SAVED_MIN) / 16];
1142 cl = smalloc(16 + strlen(session)); /* 8, but play safe */
1144 cl = NULL; /* not a very important failure mode */
1146 sprintf(cl, "putty @%s", session);
1152 GetModuleFileName (NULL, b, sizeof(b)-1);
1154 si.lpReserved = NULL;
1155 si.lpDesktop = NULL;
1159 si.lpReserved2 = NULL;
1160 CreateProcess (b, cl, NULL, NULL, TRUE,
1161 NORMAL_PRIORITY_CLASS, NULL, NULL, &si, &pi);
1164 CloseHandle(filemap);
1171 int prev_alwaysontop = cfg.alwaysontop;
1172 if (!do_reconfig(hwnd))
1174 just_reconfigged = TRUE;
1179 DeleteObject(fonts[i]);
1181 bold_mode = cfg.bold_colour ? BOLD_COLOURS : BOLD_FONT;
1182 und_mode = UND_FONT;
1186 * Telnet will change local echo -> remote if the
1189 if (cfg.protocol != PROT_TELNET)
1190 ldisc = (cfg.ldisc_term ? &ldisc_term : &ldisc_simple);
1198 /* Enable or disable the scroll bar, etc */
1200 LONG nflg, flag = GetWindowLong(hwnd, GWL_STYLE);
1201 LONG nexflag, exflag = GetWindowLong(hwnd, GWL_EXSTYLE);
1204 if (cfg.alwaysontop != prev_alwaysontop) {
1205 if (cfg.alwaysontop) {
1206 nexflag = WS_EX_TOPMOST;
1207 SetWindowPos(hwnd, HWND_TOPMOST, 0, 0, 0, 0,
1208 SWP_NOMOVE | SWP_NOSIZE);
1211 SetWindowPos(hwnd, HWND_NOTOPMOST, 0, 0, 0, 0,
1212 SWP_NOMOVE | SWP_NOSIZE);
1217 if (cfg.scrollbar) nflg |= WS_VSCROLL;
1218 else nflg &= ~WS_VSCROLL;
1220 nflg &= ~(WS_THICKFRAME|WS_MAXIMIZEBOX);
1222 nflg |= (WS_THICKFRAME|WS_MAXIMIZEBOX);
1224 if (nflg != flag || nexflag != exflag)
1229 SetWindowLong(hwnd, GWL_STYLE, nflg);
1230 if (nexflag != exflag)
1231 SetWindowLong(hwnd, GWL_EXSTYLE, nexflag);
1233 SendMessage (hwnd, WM_IGNORE_SIZE, 0, 0);
1234 SetWindowPos(hwnd, NULL, 0,0,0,0,
1235 SWP_NOACTIVATE|SWP_NOCOPYBITS|
1236 SWP_NOMOVE|SWP_NOSIZE|SWP_NOZORDER|
1239 GetWindowRect (hwnd, &wr);
1240 GetClientRect (hwnd, &cr);
1241 extra_width = wr.right - wr.left - cr.right + cr.left;
1242 extra_height = wr.bottom - wr.top - cr.bottom + cr.top;
1246 term_size(cfg.height, cfg.width, cfg.savelines);
1247 InvalidateRect(hwnd, NULL, TRUE);
1248 SetWindowPos (hwnd, NULL, 0, 0,
1249 extra_width + font_width * cfg.width,
1250 extra_height + font_height * cfg.height,
1251 SWP_NOACTIVATE | SWP_NOCOPYBITS |
1252 SWP_NOMOVE | SWP_NOZORDER);
1253 if (IsIconic(hwnd)) {
1254 SetWindowText (hwnd,
1255 cfg.win_name_always ? window_name : icon_name);
1268 case IDM_TEL_AYT: back->special (TS_AYT); break;
1269 case IDM_TEL_BRK: back->special (TS_BRK); break;
1270 case IDM_TEL_SYNCH: back->special (TS_SYNCH); break;
1271 case IDM_TEL_EC: back->special (TS_EC); break;
1272 case IDM_TEL_EL: back->special (TS_EL); break;
1273 case IDM_TEL_GA: back->special (TS_GA); break;
1274 case IDM_TEL_NOP: back->special (TS_NOP); break;
1275 case IDM_TEL_ABORT: back->special (TS_ABORT); break;
1276 case IDM_TEL_AO: back->special (TS_AO); break;
1277 case IDM_TEL_IP: back->special (TS_IP); break;
1278 case IDM_TEL_SUSP: back->special (TS_SUSP); break;
1279 case IDM_TEL_EOR: back->special (TS_EOR); break;
1280 case IDM_TEL_EOF: back->special (TS_EOF); break;
1285 if (wParam >= IDM_SAVED_MIN && wParam <= IDM_SAVED_MAX) {
1286 SendMessage(hwnd, WM_SYSCOMMAND, IDM_SAVEDSESS, wParam);
1291 #define X_POS(l) ((int)(short)LOWORD(l))
1292 #define Y_POS(l) ((int)(short)HIWORD(l))
1294 #define TO_CHR_X(x) (((x)<0 ? (x)-font_width+1 : (x)) / font_width)
1295 #define TO_CHR_Y(y) (((y)<0 ? (y)-font_height+1: (y)) / font_height)
1297 case WM_LBUTTONDOWN:
1298 click (MB_SELECT, TO_CHR_X(X_POS(lParam)),
1299 TO_CHR_Y(Y_POS(lParam)));
1303 term_mouse (MB_SELECT, MA_RELEASE, TO_CHR_X(X_POS(lParam)),
1304 TO_CHR_Y(Y_POS(lParam)));
1307 case WM_MBUTTONDOWN:
1309 click (cfg.mouse_is_xterm ? MB_PASTE : MB_EXTEND,
1310 TO_CHR_X(X_POS(lParam)),
1311 TO_CHR_Y(Y_POS(lParam)));
1314 term_mouse (cfg.mouse_is_xterm ? MB_PASTE : MB_EXTEND,
1315 MA_RELEASE, TO_CHR_X(X_POS(lParam)),
1316 TO_CHR_Y(Y_POS(lParam)));
1319 case WM_RBUTTONDOWN:
1321 click (cfg.mouse_is_xterm ? MB_EXTEND : MB_PASTE,
1322 TO_CHR_X(X_POS(lParam)),
1323 TO_CHR_Y(Y_POS(lParam)));
1326 term_mouse (cfg.mouse_is_xterm ? MB_EXTEND : MB_PASTE,
1327 MA_RELEASE, TO_CHR_X(X_POS(lParam)),
1328 TO_CHR_Y(Y_POS(lParam)));
1333 * Add the mouse position and message time to the random
1336 noise_ultralight(lParam);
1338 if (wParam & (MK_LBUTTON | MK_MBUTTON | MK_RBUTTON)) {
1340 if (wParam & MK_LBUTTON)
1342 else if (wParam & MK_MBUTTON)
1343 b = cfg.mouse_is_xterm ? MB_PASTE : MB_EXTEND;
1345 b = cfg.mouse_is_xterm ? MB_EXTEND : MB_PASTE;
1346 term_mouse (b, MA_DRAG, TO_CHR_X(X_POS(lParam)),
1347 TO_CHR_Y(Y_POS(lParam)));
1350 case WM_IGNORE_CLIP:
1351 ignore_clip = wParam; /* don't panic on DESTROYCLIPBOARD */
1353 case WM_DESTROYCLIPBOARD:
1356 ignore_clip = FALSE;
1362 hdc = BeginPaint (hwnd, &p);
1364 SelectPalette (hdc, pal, TRUE);
1365 RealizePalette (hdc);
1367 term_paint (hdc, p.rcPaint.left, p.rcPaint.top,
1368 p.rcPaint.right, p.rcPaint.bottom);
1369 SelectObject (hdc, GetStockObject(SYSTEM_FONT));
1370 SelectObject (hdc, GetStockObject(WHITE_PEN));
1371 EndPaint (hwnd, &p);
1376 /* Notice we can get multiple netevents, FD_READ, FD_WRITE etc
1377 * but the only one that's likely to try to overload us is FD_READ.
1378 * This means buffering just one is fine.
1380 if (pending_netevent)
1381 enact_pending_netevent();
1383 pending_netevent = TRUE;
1384 pend_netevent_wParam=wParam;
1385 pend_netevent_lParam=lParam;
1386 time(&last_movement);
1390 CreateCaret(hwnd, caretbm, 0, 0);
1402 case WM_IGNORE_SIZE:
1403 ignore_size = TRUE; /* don't panic on next WM_SIZE msg */
1405 case WM_ENTERSIZEMOVE:
1409 case WM_EXITSIZEMOVE:
1416 int width, height, w, h, ew, eh;
1417 LPRECT r = (LPRECT)lParam;
1419 width = r->right - r->left - extra_width;
1420 height = r->bottom - r->top - extra_height;
1421 w = (width + font_width/2) / font_width; if (w < 1) w = 1;
1422 h = (height + font_height/2) / font_height; if (h < 1) h = 1;
1423 UpdateSizeTip(hwnd, w, h);
1424 ew = width - w * font_width;
1425 eh = height - h * font_height;
1427 if (wParam == WMSZ_LEFT ||
1428 wParam == WMSZ_BOTTOMLEFT ||
1429 wParam == WMSZ_TOPLEFT)
1435 if (wParam == WMSZ_TOP ||
1436 wParam == WMSZ_TOPRIGHT ||
1437 wParam == WMSZ_TOPLEFT)
1447 /* break; (never reached) */
1449 if (wParam == SIZE_MINIMIZED) {
1450 SetWindowText (hwnd,
1451 cfg.win_name_always ? window_name : icon_name);
1454 if (wParam == SIZE_RESTORED || wParam == SIZE_MAXIMIZED)
1455 SetWindowText (hwnd, window_name);
1457 int width, height, w, h;
1458 #if 0 /* we have fixed this using WM_SIZING now */
1462 width = LOWORD(lParam);
1463 height = HIWORD(lParam);
1464 w = width / font_width; if (w < 1) w = 1;
1465 h = height / font_height; if (h < 1) h = 1;
1466 #if 0 /* we have fixed this using WM_SIZING now */
1467 ew = width - w * font_width;
1468 eh = height - h * font_height;
1469 if (ew != 0 || eh != 0) {
1471 GetWindowRect (hwnd, &r);
1472 SendMessage (hwnd, WM_IGNORE_SIZE, 0, 0);
1473 SetWindowPos (hwnd, NULL, 0, 0,
1474 r.right - r.left - ew, r.bottom - r.top - eh,
1475 SWP_NOACTIVATE | SWP_NOMOVE | SWP_NOZORDER);
1478 if (w != cols || h != rows || just_reconfigged) {
1480 term_size (h, w, cfg.savelines);
1482 * Don't call back->size in mid-resize. (To prevent
1483 * massive numbers of resize events getting sent
1484 * down the connection during an NT opaque drag.)
1488 just_reconfigged = FALSE;
1491 ignore_size = FALSE;
1494 switch (LOWORD(wParam)) {
1495 case SB_BOTTOM: term_scroll(-1, 0); break;
1496 case SB_TOP: term_scroll(+1, 0); break;
1497 case SB_LINEDOWN: term_scroll (0, +1); break;
1498 case SB_LINEUP: term_scroll (0, -1); break;
1499 case SB_PAGEDOWN: term_scroll (0, +rows/2); break;
1500 case SB_PAGEUP: term_scroll (0, -rows/2); break;
1501 case SB_THUMBPOSITION: case SB_THUMBTRACK:
1502 term_scroll (1, HIWORD(wParam)); break;
1505 case WM_PALETTECHANGED:
1506 if ((HWND) wParam != hwnd && pal != NULL) {
1507 HDC hdc = get_ctx();
1509 if (RealizePalette (hdc) > 0)
1515 case WM_QUERYNEWPALETTE:
1517 HDC hdc = get_ctx();
1519 if (RealizePalette (hdc) > 0)
1531 * Add the scan code and keypress timing to the random
1534 noise_ultralight(lParam);
1537 * We don't do TranslateMessage since it disassociates the
1538 * resulting CHAR message from the KEYDOWN that sparked it,
1539 * which we occasionally don't want. Instead, we process
1540 * KEYDOWN, and call the Win32 translator functions so that
1541 * we get the translations under _our_ control.
1544 unsigned char buf[20];
1547 if (wParam==VK_PROCESSKEY) {
1550 m.message = WM_KEYDOWN;
1552 m.lParam = lParam & 0xdfff;
1553 TranslateMessage(&m);
1555 len = TranslateKey (message, wParam, lParam, buf);
1557 return DefWindowProc (hwnd, message, wParam, lParam);
1558 ldisc->send (buf, len);
1564 unsigned char buf[2];
1567 buf[0] = wParam >> 8;
1568 ldisc->send (buf, 2);
1573 * Nevertheless, we are prepared to deal with WM_CHAR
1574 * messages, should they crop up. So if someone wants to
1575 * post the things to us as part of a macro manoeuvre,
1576 * we're ready to cope.
1579 char c = xlat_kbd2tty((unsigned char)wParam);
1580 ldisc->send (&c, 1);
1585 return DefWindowProc (hwnd, message, wParam, lParam);
1589 * Move the system caret. (We maintain one, even though it's
1590 * invisible, for the benefit of blind people: apparently some
1591 * helper software tracks the system caret, so we should arrange to
1594 void sys_cursor(int x, int y) {
1595 SetCaretPos(x * font_width, y * font_height);
1599 * Draw a line of text in the window, at given character
1600 * coordinates, in given attributes.
1602 * We are allowed to fiddle with the contents of `text'.
1604 void do_text (Context ctx, int x, int y, char *text, int len,
1605 unsigned long attr, int lattr) {
1607 int nfg, nbg, nfont;
1610 int force_manual_underline = 0;
1611 int fnt_width = font_width*(1+(lattr!=LATTR_NORM));
1612 static int *IpDx = 0, IpDxLEN = 0;;
1614 if (len>IpDxLEN || IpDx[0] != fnt_width) {
1618 IpDx = smalloc((len+16)*sizeof(int));
1621 for(i=0; i<IpDxLEN; i++)
1622 IpDx[i] = fnt_width;
1628 if (attr & ATTR_ACTCURS) {
1629 attr &= (bold_mode == BOLD_COLOURS ? 0x300200 : 0x300300);
1630 attr ^= ATTR_CUR_XOR;
1634 if (cfg.vtmode == VT_OEMONLY)
1638 * Map high-half characters in order to approximate ISO using
1639 * OEM character set. No characters are missing if the OEM codepage
1642 if (nfont & FONT_OEM) {
1644 for (i=0; i<len; i++)
1645 if (text[i] >= '\xA0' && text[i] <= '\xFF') {
1647 /* This is CP850 ... perfect translation */
1648 static const char oemhighhalf[] =
1649 "\x20\xAD\xBD\x9C\xCF\xBE\xDD\xF5" /* A0-A7 */
1650 "\xF9\xB8\xA6\xAE\xAA\xF0\xA9\xEE" /* A8-AF */
1651 "\xF8\xF1\xFD\xFC\xEF\xE6\xF4\xFA" /* B0-B7 */
1652 "\xF7\xFB\xA7\xAF\xAC\xAB\xF3\xA8" /* B8-BF */
1653 "\xB7\xB5\xB6\xC7\x8E\x8F\x92\x80" /* C0-C7 */
1654 "\xD4\x90\xD2\xD3\xDE\xD6\xD7\xD8" /* C8-CF */
1655 "\xD1\xA5\xE3\xE0\xE2\xE5\x99\x9E" /* D0-D7 */
1656 "\x9D\xEB\xE9\xEA\x9A\xED\xE8\xE1" /* D8-DF */
1657 "\x85\xA0\x83\xC6\x84\x86\x91\x87" /* E0-E7 */
1658 "\x8A\x82\x88\x89\x8D\xA1\x8C\x8B" /* E8-EF */
1659 "\xD0\xA4\x95\xA2\x93\xE4\x94\xF6" /* F0-F7 */
1660 "\x9B\x97\xA3\x96\x81\xEC\xE7\x98" /* F8-FF */
1663 /* This is CP437 ... junk translation */
1664 static const unsigned char oemhighhalf[] = {
1665 0xff, 0xad, 0x9b, 0x9c, 0x6f, 0x9d, 0x7c, 0x15,
1666 0x22, 0x43, 0xa6, 0xae, 0xaa, 0x2d, 0x52, 0xc4,
1667 0xf8, 0xf1, 0xfd, 0x33, 0x27, 0xe6, 0x14, 0xfa,
1668 0x2c, 0x31, 0xa7, 0xaf, 0xac, 0xab, 0x2f, 0xa8,
1669 0x41, 0x41, 0x41, 0x41, 0x8e, 0x8f, 0x92, 0x80,
1670 0x45, 0x90, 0x45, 0x45, 0x49, 0x49, 0x49, 0x49,
1671 0x44, 0xa5, 0x4f, 0x4f, 0x4f, 0x4f, 0x99, 0x78,
1672 0xed, 0x55, 0x55, 0x55, 0x9a, 0x59, 0x50, 0xe1,
1673 0x85, 0xa0, 0x83, 0x61, 0x84, 0x86, 0x91, 0x87,
1674 0x8a, 0x82, 0x88, 0x89, 0x8d, 0xa1, 0x8c, 0x8b,
1675 0x0b, 0xa4, 0x95, 0xa2, 0x93, 0x6f, 0x94, 0xf6,
1676 0xed, 0x97, 0xa3, 0x96, 0x81, 0x79, 0x70, 0x98
1679 text[i] = oemhighhalf[(unsigned char)text[i] - 0xA0];
1683 if (attr & ATTR_LINEDRW) {
1686 static const char poorman[] =
1687 "*#****\xB0\xB1**+++++-----++++|****\xA3\xB7";
1690 static const char oemmap_437[] =
1691 "\x04\xB1****\xF8\xF1**\xD9\xBF\xDA\xC0\xC5"
1692 "\xC4\xC4\xC4\xC4\xC4\xC3\xB4\xC1\xC2\xB3\xF3\xF2\xE3*\x9C\xFA";
1695 static const char oemmap_850[] =
1696 "\x04\xB1****\xF8\xF1**\xD9\xBF\xDA\xC0\xC5"
1697 "\xC4\xC4\xC4\xC4\xC4\xC3\xB4\xC1\xC2\xB3****\x9C\xFA";
1699 /* Poor windows font ... eg: windows courier */
1700 static const char oemmap[] =
1701 "*\xB1****\xF8\xF1**\xD9\xBF\xDA\xC0\xC5"
1702 "\xC4\xC4\xC4\xC4\xC4\xC3\xB4\xC1\xC2\xB3****\x9C\xFA";
1705 * Line drawing mapping: map ` thru ~ (0x60 thru 0x7E) to
1706 * VT100 line drawing chars; everything else stays normal.
1708 * Actually '_' maps to space too, but that's done before.
1710 switch (cfg.vtmode) {
1712 for (i=0; i<len; i++)
1713 if (text[i] >= '\x60' && text[i] <= '\x7E')
1714 text[i] += '\x01' - '\x60';
1717 /* Make sure we actually have an OEM font */
1718 if (fonts[nfont|FONT_OEM]) {
1721 for (i=0; i<len; i++)
1722 if (text[i] >= '\x60' && text[i] <= '\x7E')
1723 text[i] = oemmap[(unsigned char)text[i] - 0x60];
1727 for (i=0; i<len; i++)
1728 if (text[i] >= '\x60' && text[i] <= '\x7E')
1729 text[i] = poorman[(unsigned char)text[i] - 0x60];
1734 nfg = 2 * ((attr & ATTR_FGMASK) >> ATTR_FGSHIFT);
1735 nbg = 2 * ((attr & ATTR_BGMASK) >> ATTR_BGSHIFT);
1736 if (bold_mode == BOLD_FONT && (attr & ATTR_BOLD))
1738 if (und_mode == UND_FONT && (attr & ATTR_UNDER))
1739 nfont |= FONT_UNDERLINE;
1742 if (nfont&FONT_UNDERLINE)
1743 force_manual_underline = 1;
1744 /* Don't do the same for manual bold, it could be bad news. */
1746 nfont &= ~(FONT_BOLD|FONT_UNDERLINE);
1748 if (font_needs_hand_underlining && (attr & ATTR_UNDER))
1749 force_manual_underline = 1;
1750 if (attr & ATTR_REVERSE) {
1751 t = nfg; nfg = nbg; nbg = t;
1753 if (bold_mode == BOLD_COLOURS && (attr & ATTR_BOLD))
1755 if (bold_mode == BOLD_COLOURS && (attr & ATTR_BLINK))
1759 SelectObject (hdc, fonts[nfont]);
1760 SetTextColor (hdc, fg);
1761 SetBkColor (hdc, bg);
1762 SetBkMode (hdc, OPAQUE);
1765 line_box.right = x+fnt_width*len;
1766 line_box.bottom = y+font_height;
1767 ExtTextOut (hdc, x, y, ETO_CLIPPED|ETO_OPAQUE, &line_box, text, len, IpDx);
1768 if (bold_mode == BOLD_SHADOW && (attr & ATTR_BOLD)) {
1769 SetBkMode (hdc, TRANSPARENT);
1771 /* GRR: This draws the character outside it's box and can leave
1772 * 'droppings' even with the clip box! I suppose I could loop it
1773 * one character at a time ... yuk.
1775 * Or ... I could do a test print with "W", and use +1 or -1 for this
1776 * shift depending on if the leftmost column is blank...
1778 ExtTextOut (hdc, x-1, y, ETO_CLIPPED, &line_box, text, len, IpDx);
1780 if (force_manual_underline ||
1781 (und_mode == UND_LINE && (attr & ATTR_UNDER))) {
1783 oldpen = SelectObject (hdc, CreatePen(PS_SOLID, 0, fg));
1784 MoveToEx (hdc, x, y+descent, NULL);
1785 LineTo (hdc, x+len*fnt_width, y+descent);
1786 oldpen = SelectObject (hdc, oldpen);
1787 DeleteObject (oldpen);
1789 if (attr & ATTR_PASCURS) {
1792 pts[0].x = pts[1].x = pts[4].x = x;
1793 pts[2].x = pts[3].x = x+fnt_width-1;
1794 pts[0].y = pts[3].y = pts[4].y = y;
1795 pts[1].y = pts[2].y = y+font_height-1;
1796 oldpen = SelectObject (hdc, CreatePen(PS_SOLID, 0, colours[23]));
1797 Polyline (hdc, pts, 5);
1798 oldpen = SelectObject (hdc, oldpen);
1799 DeleteObject (oldpen);
1803 static int check_compose(int first, int second) {
1805 static char * composetbl[] = {
1806 "++#", "AA@", "(([", "//\\", "))]", "(-{", "-)}", "/^|", "!!¡", "C/¢",
1807 "C|¢", "L-£", "L=£", "XO¤", "X0¤", "Y-¥", "Y=¥", "||¦", "SO§", "S!§",
1808 "S0§", "\"\"¨", "CO©", "C0©", "A_ª", "<<«", ",-¬", "--", "RO®",
1809 "-^¯", "0^°", "+-±", "2^²", "3^³", "''´", "/Uµ", "P!¶", ".^·", ",,¸",
1810 "1^¹", "O_º", ">>»", "14¼", "12½", "34¾", "??¿", "`AÀ", "'AÁ", "^AÂ",
1811 "~AÃ", "\"AÄ", "*AÅ", "AEÆ", ",CÇ", "`EÈ", "'EÉ", "^EÊ", "\"EË",
1812 "`IÌ", "'IÍ", "^IÎ", "\"IÏ", "-DÐ", "~NÑ", "`OÒ", "'OÓ", "^OÔ",
1813 "~OÕ", "\"OÖ", "XX×", "/OØ", "`UÙ", "'UÚ", "^UÛ", "\"UÜ", "'YÝ",
1814 "HTÞ", "ssß", "`aà", "'aá", "^aâ", "~aã", "\"aä", "*aå", "aeæ", ",cç",
1815 "`eè", "'eé", "^eê", "\"eë", "`iì", "'ií", "^iî", "\"iï", "-dð", "~nñ",
1816 "`oò", "'oó", "^oô", "~oõ", "\"oö", ":-÷", "o/ø", "`uù", "'uú", "^uû",
1817 "\"uü", "'yý", "htþ", "\"yÿ",
1821 static int recurse = 0;
1824 for(c=composetbl; *c; c++) {
1825 if( (*c)[0] == first && (*c)[1] == second)
1827 return (*c)[2] & 0xFF;
1834 nc = check_compose(second, first);
1836 nc = check_compose(toupper(first), toupper(second));
1838 nc = check_compose(toupper(second), toupper(first));
1846 * Translate a WM_(SYS)?KEY(UP|DOWN) message into a string of ASCII
1847 * codes. Returns number of bytes used or zero to drop the message
1848 * or -1 to forward the message to windows.
1850 static int TranslateKey(UINT message, WPARAM wParam, LPARAM lParam,
1851 unsigned char *output) {
1853 int scan, left_alt = 0, key_down, shift_state;
1855 unsigned char * p = output;
1857 static WORD keys[3];
1858 static int compose_char = 0;
1859 static WPARAM compose_key = 0;
1861 r = GetKeyboardState(keystate);
1862 if (!r) memset(keystate, 0, sizeof(keystate));
1866 { /* Tell us all about key events */
1867 static BYTE oldstate[256];
1868 static int first = 1;
1871 if(first) memcpy(oldstate, keystate, sizeof(oldstate));
1874 if ((HIWORD(lParam)&(KF_UP|KF_REPEAT))==KF_REPEAT) {
1876 } else if ((HIWORD(lParam)&KF_UP) && scan==(HIWORD(lParam) & 0xFF) ) {
1880 if (wParam >= VK_F1 && wParam <= VK_F20 )
1881 debug(("K_F%d", wParam+1-VK_F1));
1884 case VK_SHIFT: debug(("SHIFT")); break;
1885 case VK_CONTROL: debug(("CTRL")); break;
1886 case VK_MENU: debug(("ALT")); break;
1887 default: debug(("VK_%02x", wParam));
1889 if(message == WM_SYSKEYDOWN || message == WM_SYSKEYUP)
1891 debug((", S%02x", scan=(HIWORD(lParam) & 0xFF) ));
1893 ch = MapVirtualKey(wParam, 2);
1894 if (ch>=' ' && ch<='~') debug((", '%c'", ch));
1895 else if (ch) debug((", $%02x", ch));
1897 if (keys[0]) debug((", KB0=%02x", keys[0]));
1898 if (keys[1]) debug((", KB1=%02x", keys[1]));
1899 if (keys[2]) debug((", KB2=%02x", keys[2]));
1901 if ( (keystate[VK_SHIFT]&0x80)!=0) debug((", S"));
1902 if ( (keystate[VK_CONTROL]&0x80)!=0) debug((", C"));
1903 if ( (HIWORD(lParam)&KF_EXTENDED) ) debug((", E"));
1904 if ( (HIWORD(lParam)&KF_UP) ) debug((", U"));
1907 if ((HIWORD(lParam)&(KF_UP|KF_REPEAT))==KF_REPEAT)
1909 else if ( (HIWORD(lParam)&KF_UP) )
1910 oldstate[wParam&0xFF] ^= 0x80;
1912 oldstate[wParam&0xFF] ^= 0x81;
1914 for(ch=0; ch<256; ch++)
1915 if (oldstate[ch] != keystate[ch])
1916 debug((", M%02x=%02x", ch, keystate[ch]));
1918 memcpy(oldstate, keystate, sizeof(oldstate));
1922 if (wParam == VK_MENU && (HIWORD(lParam)&KF_EXTENDED)) {
1923 keystate[VK_RMENU] = keystate[VK_MENU];
1926 /* Note if AltGr was pressed and if it was used as a compose key */
1927 if (cfg.compose_key) {
1928 if (wParam == VK_MENU && (HIWORD(lParam)&KF_EXTENDED))
1930 if (!compose_state) compose_key = wParam;
1932 if (wParam == VK_APPS && !compose_state)
1933 compose_key = wParam;
1935 if (wParam == compose_key)
1937 if (compose_state == 0 && (HIWORD(lParam)&(KF_UP|KF_REPEAT))==0)
1939 else if (compose_state == 1 && (HIWORD(lParam)&KF_UP))
1944 else if (compose_state==1 && wParam != VK_CONTROL)
1950 /* Nastyness with NUMLock - Shift-NUMLock is left alone though */
1951 if ( (cfg.funky_type == 3 ||
1952 (cfg.funky_type <= 1 && app_keypad_keys && !cfg.no_applic_k))
1953 && wParam==VK_NUMLOCK && !(keystate[VK_SHIFT]&0x80)) {
1955 wParam = VK_EXECUTE;
1957 /* UnToggle NUMLock */
1958 if ((HIWORD(lParam)&(KF_UP|KF_REPEAT))==0)
1959 keystate[VK_NUMLOCK] ^= 1;
1962 /* And write back the 'adjusted' state */
1963 SetKeyboardState (keystate);
1966 /* Disable Auto repeat if required */
1967 if (repeat_off && (HIWORD(lParam)&(KF_UP|KF_REPEAT))==KF_REPEAT)
1970 if ((HIWORD(lParam)&KF_ALTDOWN) && (keystate[VK_RMENU]&0x80) == 0)
1973 key_down = ((HIWORD(lParam)&KF_UP)==0);
1975 /* Make sure Ctrl-ALT is not the same as AltGr for ToAscii */
1976 if (left_alt && (keystate[VK_CONTROL]&0x80))
1977 keystate[VK_MENU] = 0;
1979 scan = (HIWORD(lParam) & (KF_UP | KF_EXTENDED | 0xFF));
1980 shift_state = ((keystate[VK_SHIFT]&0x80)!=0)
1981 + ((keystate[VK_CONTROL]&0x80)!=0)*2;
1984 * Record that we pressed key so the scroll window can be reset, but
1985 * be careful to avoid Shift-UP/Down
1987 if( wParam != VK_SHIFT && wParam != VK_PRIOR && wParam != VK_NEXT ) {
1991 /* Make sure we're not pasting */
1992 if (key_down) term_nopaste();
1994 if (compose_state>1 && left_alt) compose_state = 0;
1996 /* Sanitize the number pad if not using a PC NumPad */
1997 if( left_alt || (app_keypad_keys && !cfg.no_applic_k
1998 && cfg.funky_type != 2)
1999 || cfg.funky_type == 3 || cfg.nethack_keypad || compose_state )
2001 if ((HIWORD(lParam)&KF_EXTENDED) == 0)
2006 case VK_INSERT: nParam = VK_NUMPAD0; break;
2007 case VK_END: nParam = VK_NUMPAD1; break;
2008 case VK_DOWN: nParam = VK_NUMPAD2; break;
2009 case VK_NEXT: nParam = VK_NUMPAD3; break;
2010 case VK_LEFT: nParam = VK_NUMPAD4; break;
2011 case VK_CLEAR: nParam = VK_NUMPAD5; break;
2012 case VK_RIGHT: nParam = VK_NUMPAD6; break;
2013 case VK_HOME: nParam = VK_NUMPAD7; break;
2014 case VK_UP: nParam = VK_NUMPAD8; break;
2015 case VK_PRIOR: nParam = VK_NUMPAD9; break;
2016 case VK_DELETE: nParam = VK_DECIMAL; break;
2020 if (keystate[VK_NUMLOCK]&1) shift_state |= 1;
2026 /* If a key is pressed and AltGr is not active */
2027 if (key_down && (keystate[VK_RMENU]&0x80) == 0 && !compose_state)
2029 /* Okay, prepare for most alts then ...*/
2030 if (left_alt) *p++ = '\033';
2032 /* Lets see if it's a pattern we know all about ... */
2033 if (wParam == VK_PRIOR && shift_state == 1) {
2034 SendMessage (hwnd, WM_VSCROLL, SB_PAGEUP, 0);
2037 if (wParam == VK_NEXT && shift_state == 1) {
2038 SendMessage (hwnd, WM_VSCROLL, SB_PAGEDOWN, 0);
2041 if (wParam == VK_INSERT && shift_state == 1) {
2042 term_mouse (MB_PASTE, MA_CLICK, 0, 0);
2043 term_mouse (MB_PASTE, MA_RELEASE, 0, 0);
2046 if (left_alt && wParam == VK_F4 && cfg.alt_f4) {
2049 if (left_alt && wParam == VK_SPACE && cfg.alt_space) {
2050 PostMessage(hwnd, WM_CHAR, ' ', 0);
2051 SendMessage (hwnd, WM_SYSCOMMAND, SC_KEYMENU, 0);
2054 /* Control-Numlock for app-keypad mode switch */
2055 if (wParam == VK_PAUSE && shift_state == 2) {
2056 app_keypad_keys ^= 1;
2060 /* Nethack keypad */
2061 if (cfg.nethack_keypad && !left_alt) {
2063 case VK_NUMPAD1: *p++ = shift_state ? 'B': 'b'; return p-output;
2064 case VK_NUMPAD2: *p++ = shift_state ? 'J': 'j'; return p-output;
2065 case VK_NUMPAD3: *p++ = shift_state ? 'N': 'n'; return p-output;
2066 case VK_NUMPAD4: *p++ = shift_state ? 'H': 'h'; return p-output;
2067 case VK_NUMPAD5: *p++ = shift_state ? '.': '.'; return p-output;
2068 case VK_NUMPAD6: *p++ = shift_state ? 'L': 'l'; return p-output;
2069 case VK_NUMPAD7: *p++ = shift_state ? 'Y': 'y'; return p-output;
2070 case VK_NUMPAD8: *p++ = shift_state ? 'K': 'k'; return p-output;
2071 case VK_NUMPAD9: *p++ = shift_state ? 'U': 'u'; return p-output;
2075 /* Application Keypad */
2079 if ( cfg.funky_type == 3 ||
2080 ( cfg.funky_type <= 1 &&
2081 app_keypad_keys && !cfg.no_applic_k)) switch(wParam) {
2082 case VK_EXECUTE: xkey = 'P'; break;
2083 case VK_DIVIDE: xkey = 'Q'; break;
2084 case VK_MULTIPLY:xkey = 'R'; break;
2085 case VK_SUBTRACT:xkey = 'S'; break;
2087 if(app_keypad_keys && !cfg.no_applic_k) switch(wParam) {
2088 case VK_NUMPAD0: xkey = 'p'; break;
2089 case VK_NUMPAD1: xkey = 'q'; break;
2090 case VK_NUMPAD2: xkey = 'r'; break;
2091 case VK_NUMPAD3: xkey = 's'; break;
2092 case VK_NUMPAD4: xkey = 't'; break;
2093 case VK_NUMPAD5: xkey = 'u'; break;
2094 case VK_NUMPAD6: xkey = 'v'; break;
2095 case VK_NUMPAD7: xkey = 'w'; break;
2096 case VK_NUMPAD8: xkey = 'x'; break;
2097 case VK_NUMPAD9: xkey = 'y'; break;
2099 case VK_DECIMAL: xkey = 'n'; break;
2100 case VK_ADD: if(cfg.funky_type==2) {
2101 if(shift_state) xkey = 'l';
2103 } else if(shift_state) xkey = 'm';
2107 case VK_DIVIDE: if(cfg.funky_type==2) xkey = 'o'; break;
2108 case VK_MULTIPLY:if(cfg.funky_type==2) xkey = 'j'; break;
2109 case VK_SUBTRACT:if(cfg.funky_type==2) xkey = 'm'; break;
2112 if (HIWORD(lParam)&KF_EXTENDED)
2120 if (xkey>='P' && xkey<='S')
2121 p += sprintf((char *)p, "\x1B%c", xkey);
2123 p += sprintf((char *)p, "\x1B?%c", xkey);
2126 p += sprintf((char *)p, "\x1BO%c", xkey);
2131 if (wParam == VK_BACK && shift_state == 0 ) /* Backspace */
2133 *p++ = (cfg.bksp_is_delete ? 0x7F : 0x08);
2136 if (wParam == VK_TAB && shift_state == 1 ) /* Shift tab */
2138 *p++ = 0x1B; *p++ = '['; *p++ = 'Z'; return p - output;
2140 if (wParam == VK_SPACE && shift_state == 2 ) /* Ctrl-Space */
2142 *p++ = 0; return p - output;
2144 if (wParam == VK_SPACE && shift_state == 3 ) /* Ctrl-Shift-Space */
2146 *p++ = 160; return p - output;
2148 if (wParam == VK_CANCEL && shift_state == 2 ) /* Ctrl-Break */
2150 *p++ = 3; return p - output;
2152 /* Control-2 to Control-8 are special */
2153 if (shift_state == 2 && wParam >= '2' && wParam <= '8')
2155 *p++ = "\000\033\034\035\036\037\177"[wParam-'2'];
2158 if (shift_state == 2 && wParam == 0xBD) {
2162 if (shift_state == 2 && wParam == 0xDF) {
2166 if (shift_state == 0 && wParam == VK_RETURN && cr_lf_return) {
2167 *p++ = '\r'; *p++ = '\n';
2172 * Next, all the keys that do tilde codes. (ESC '[' nn '~',
2173 * for integer decimal nn.)
2175 * We also deal with the weird ones here. Linux VCs replace F1
2176 * to F5 by ESC [ [ A to ESC [ [ E. rxvt doesn't do _that_, but
2177 * does replace Home and End (1~ and 4~) by ESC [ H and ESC O w
2182 case VK_F1: code = (keystate[VK_SHIFT] & 0x80 ? 23 : 11); break;
2183 case VK_F2: code = (keystate[VK_SHIFT] & 0x80 ? 24 : 12); break;
2184 case VK_F3: code = (keystate[VK_SHIFT] & 0x80 ? 25 : 13); break;
2185 case VK_F4: code = (keystate[VK_SHIFT] & 0x80 ? 26 : 14); break;
2186 case VK_F5: code = (keystate[VK_SHIFT] & 0x80 ? 28 : 15); break;
2187 case VK_F6: code = (keystate[VK_SHIFT] & 0x80 ? 29 : 17); break;
2188 case VK_F7: code = (keystate[VK_SHIFT] & 0x80 ? 31 : 18); break;
2189 case VK_F8: code = (keystate[VK_SHIFT] & 0x80 ? 32 : 19); break;
2190 case VK_F9: code = (keystate[VK_SHIFT] & 0x80 ? 33 : 20); break;
2191 case VK_F10: code = (keystate[VK_SHIFT] & 0x80 ? 34 : 21); break;
2192 case VK_F11: code = 23; break;
2193 case VK_F12: code = 24; break;
2194 case VK_F13: code = 25; break;
2195 case VK_F14: code = 26; break;
2196 case VK_F15: code = 28; break;
2197 case VK_F16: code = 29; break;
2198 case VK_F17: code = 31; break;
2199 case VK_F18: code = 32; break;
2200 case VK_F19: code = 33; break;
2201 case VK_F20: code = 34; break;
2202 case VK_HOME: code = 1; break;
2203 case VK_INSERT: code = 2; break;
2204 case VK_DELETE: code = 3; break;
2205 case VK_END: code = 4; break;
2206 case VK_PRIOR: code = 5; break;
2207 case VK_NEXT: code = 6; break;
2209 /* Reorder edit keys to physical order */
2210 if (cfg.funky_type == 3 && code <= 6 ) code = "\0\2\1\4\5\3\6"[code];
2212 if (cfg.funky_type == 1 && code >= 11 && code <= 15) {
2213 p += sprintf((char *)p, "\x1B[[%c", code + 'A' - 11);
2216 if (cfg.funky_type == 2 && code >= 11 && code <= 14) {
2218 p += sprintf((char *)p, "\x1B%c", code + 'P' - 11);
2220 p += sprintf((char *)p, "\x1BO%c", code + 'P' - 11);
2223 if (cfg.rxvt_homeend && (code == 1 || code == 4)) {
2224 p += sprintf((char *)p, code == 1 ? "\x1B[H" : "\x1BOw");
2228 p += sprintf((char *)p, "\x1B[%d~", code);
2233 * Now the remaining keys (arrows and Keypad 5. Keypad 5 for
2234 * some reason seems to send VK_CLEAR to Windows...).
2239 case VK_UP: xkey = 'A'; break;
2240 case VK_DOWN: xkey = 'B'; break;
2241 case VK_RIGHT: xkey = 'C'; break;
2242 case VK_LEFT: xkey = 'D'; break;
2243 case VK_CLEAR: xkey = 'G'; break;
2248 p += sprintf((char *)p, "\x1B%c", xkey);
2249 else if (app_cursor_keys && !cfg.no_applic_c)
2250 p += sprintf((char *)p, "\x1BO%c", xkey);
2252 p += sprintf((char *)p, "\x1B[%c", xkey);
2258 * Finally, deal with Return ourselves. (Win95 seems to
2259 * foul it up when Alt is pressed, for some reason.)
2261 if (wParam == VK_RETURN) /* Return */
2268 /* Okay we've done everything interesting; let windows deal with
2269 * the boring stuff */
2271 BOOL capsOn=keystate[VK_CAPITAL] !=0;
2273 /* helg: clear CAPS LOCK state if caps lock switches to cyrillic */
2274 if(cfg.xlat_capslockcyr)
2275 keystate[VK_CAPITAL] = 0;
2277 r = ToAscii (wParam, scan, keystate, keys, 0);
2283 unsigned char ch = (unsigned char)keys[i];
2285 if (compose_state==2 && (ch&0x80) == 0 && ch>' ') {
2290 if (compose_state==3 && (ch&0x80) == 0 && ch>' ') {
2294 if ((nc=check_compose(compose_char,ch)) == -1)
2296 MessageBeep(MB_ICONHAND);
2299 *p++ = xlat_kbd2tty((unsigned char)nc);
2305 if( left_alt && key_down ) *p++ = '\033';
2311 ch = xlat_latkbd2win(ch);
2312 *p++ = xlat_kbd2tty(ch);
2316 /* This is so the ALT-Numpad and dead keys work correctly. */
2323 /* ALT alone may or may not want to bring up the System menu */
2324 if (wParam == VK_MENU) {
2326 static int alt_state = 0;
2327 if (message == WM_SYSKEYDOWN)
2329 else if (message == WM_SYSKEYUP && alt_state)
2330 PostMessage(hwnd, WM_CHAR, ' ', 0);
2331 if (message == WM_SYSKEYUP)
2340 void set_title (char *title) {
2341 sfree (window_name);
2342 window_name = smalloc(1+strlen(title));
2343 strcpy (window_name, title);
2344 if (cfg.win_name_always || !IsIconic(hwnd))
2345 SetWindowText (hwnd, title);
2348 void set_icon (char *title) {
2350 icon_name = smalloc(1+strlen(title));
2351 strcpy (icon_name, title);
2352 if (!cfg.win_name_always && IsIconic(hwnd))
2353 SetWindowText (hwnd, title);
2356 void set_sbar (int total, int start, int page) {
2359 if (!cfg.scrollbar) return;
2361 si.cbSize = sizeof(si);
2362 si.fMask = SIF_ALL | SIF_DISABLENOSCROLL;
2364 si.nMax = total - 1;
2368 SetScrollInfo (hwnd, SB_VERT, &si, TRUE);
2371 Context get_ctx(void) {
2376 SelectPalette (hdc, pal, FALSE);
2382 void free_ctx (Context ctx) {
2383 SelectPalette (ctx, GetStockObject (DEFAULT_PALETTE), FALSE);
2384 ReleaseDC (hwnd, ctx);
2387 static void real_palette_set (int n, int r, int g, int b) {
2389 logpal->palPalEntry[n].peRed = r;
2390 logpal->palPalEntry[n].peGreen = g;
2391 logpal->palPalEntry[n].peBlue = b;
2392 logpal->palPalEntry[n].peFlags = PC_NOCOLLAPSE;
2393 colours[n] = PALETTERGB(r, g, b);
2394 SetPaletteEntries (pal, 0, NCOLOURS, logpal->palPalEntry);
2396 colours[n] = RGB(r, g, b);
2399 void palette_set (int n, int r, int g, int b) {
2400 static const int first[21] = {
2401 0, 2, 4, 6, 8, 10, 12, 14,
2402 1, 3, 5, 7, 9, 11, 13, 15,
2405 real_palette_set (first[n], r, g, b);
2407 real_palette_set (first[n]+1, r, g, b);
2409 HDC hdc = get_ctx();
2410 UnrealizeObject (pal);
2411 RealizePalette (hdc);
2416 void palette_reset (void) {
2419 for (i = 0; i < NCOLOURS; i++) {
2421 logpal->palPalEntry[i].peRed = defpal[i].rgbtRed;
2422 logpal->palPalEntry[i].peGreen = defpal[i].rgbtGreen;
2423 logpal->palPalEntry[i].peBlue = defpal[i].rgbtBlue;
2424 logpal->palPalEntry[i].peFlags = 0;
2425 colours[i] = PALETTERGB(defpal[i].rgbtRed,
2426 defpal[i].rgbtGreen,
2427 defpal[i].rgbtBlue);
2429 colours[i] = RGB(defpal[i].rgbtRed,
2430 defpal[i].rgbtGreen,
2431 defpal[i].rgbtBlue);
2436 SetPaletteEntries (pal, 0, NCOLOURS, logpal->palPalEntry);
2438 RealizePalette (hdc);
2443 void write_clip (void *data, int len, int must_deselect) {
2447 clipdata = GlobalAlloc (GMEM_DDESHARE | GMEM_MOVEABLE, len + 1);
2450 lock = GlobalLock (clipdata);
2453 memcpy (lock, data, len);
2454 ((unsigned char *) lock) [len] = 0;
2455 GlobalUnlock (clipdata);
2458 SendMessage (hwnd, WM_IGNORE_CLIP, TRUE, 0);
2460 if (OpenClipboard (hwnd)) {
2462 SetClipboardData (CF_TEXT, clipdata);
2465 GlobalFree (clipdata);
2468 SendMessage (hwnd, WM_IGNORE_CLIP, FALSE, 0);
2471 void get_clip (void **p, int *len) {
2472 static HGLOBAL clipdata = NULL;
2476 GlobalUnlock (clipdata);
2480 if (OpenClipboard (NULL)) {
2481 clipdata = GetClipboardData (CF_TEXT);
2484 *p = GlobalLock (clipdata);
2498 * Move `lines' lines from position `from' to position `to' in the
2501 void optimised_move (int to, int from, int lines) {
2505 min = (to < from ? to : from);
2506 max = to + from - min;
2508 r.left = 0; r.right = cols * font_width;
2509 r.top = min * font_height; r.bottom = (max+lines) * font_height;
2510 ScrollWindow (hwnd, 0, (to - from) * font_height, &r, &r);
2514 * Print a message box and perform a fatal exit.
2516 void fatalbox(char *fmt, ...) {
2521 vsprintf(stuff, fmt, ap);
2523 MessageBox(hwnd, stuff, "PuTTY Fatal Error", MB_ICONERROR | MB_OK);
2530 void beep(int errorbeep) {
2531 static long last_beep = 0;
2532 long now, beep_diff;
2534 now = GetTickCount();
2535 beep_diff = now-last_beep;
2537 /* Make sure we only respond to one beep per packet or so */
2538 if (beep_diff>=0 && beep_diff<50)
2542 MessageBeep(MB_ICONHAND);
2546 last_beep = GetTickCount();