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 static int compose_state = 0;
107 void begin_session(void) {
111 int WINAPI WinMain(HINSTANCE inst, HINSTANCE prev, LPSTR cmdline, int show) {
112 static char appname[] = "PuTTY";
117 int guess_width, guess_height;
120 flags = FLAG_VERBOSE | FLAG_INTERACTIVE;
122 winsock_ver = MAKEWORD(1, 1);
123 if (WSAStartup(winsock_ver, &wsadata)) {
124 MessageBox(NULL, "Unable to initialise WinSock", "WinSock Error",
125 MB_OK | MB_ICONEXCLAMATION);
128 if (LOBYTE(wsadata.wVersion) != 1 || HIBYTE(wsadata.wVersion) != 1) {
129 MessageBox(NULL, "WinSock version is incompatible with 1.1",
130 "WinSock Error", MB_OK | MB_ICONEXCLAMATION);
134 /* WISHLIST: maybe allow config tweaking even if winsock not present? */
137 InitCommonControls();
139 /* Ensure a Maximize setting in Explorer doesn't maximise the
144 * Process the command line.
149 default_protocol = DEFAULT_PROTOCOL;
150 default_port = DEFAULT_PORT;
152 do_defaults(NULL, &cfg);
155 while (*p && isspace(*p)) p++;
158 * Process command line options first. Yes, this can be
159 * done better, and it will be as soon as I have the
163 char *q = p + strcspn(p, " \t");
166 tolower(p[0]) == 's' &&
167 tolower(p[1]) == 's' &&
168 tolower(p[2]) == 'h') {
169 default_protocol = cfg.protocol = PROT_SSH;
170 default_port = cfg.port = 22;
171 } else if (q == p + 3 &&
172 tolower(p[0]) == 'l' &&
173 tolower(p[1]) == 'o' &&
174 tolower(p[2]) == 'g') {
175 logfile = "putty.log";
176 } else if (q == p + 7 &&
177 tolower(p[0]) == 'c' &&
178 tolower(p[1]) == 'l' &&
179 tolower(p[2]) == 'e' &&
180 tolower(p[3]) == 'a' &&
181 tolower(p[4]) == 'n' &&
182 tolower(p[5]) == 'u' &&
183 tolower(p[6]) == 'p') {
185 * `putty -cleanup'. Remove all registry entries
186 * associated with PuTTY, and also find and delete
187 * the random seed file.
190 "This procedure will remove ALL Registry\n"
191 "entries associated with PuTTY, and will\n"
192 "also remove the PuTTY random seed file.\n"
194 "THIS PROCESS WILL DESTROY YOUR SAVED\n"
195 "SESSIONS. Are you really sure you want\n"
198 MB_YESNO | MB_ICONWARNING) == IDYES) {
203 p = q + strspn(q, " \t");
207 * An initial @ means to activate a saved session.
211 while (i > 1 && isspace(p[i-1]))
214 do_defaults (p+1, &cfg);
215 if (!*cfg.host && !do_config()) {
219 } else if (*p == '&') {
221 * An initial & means we've been given a command line
222 * containing the hex value of a HANDLE for a file
223 * mapping object, which we must then extract as a
228 if (sscanf(p+1, "%p", &filemap) == 1 &&
229 (cp = MapViewOfFile(filemap, FILE_MAP_READ,
230 0, 0, sizeof(Config))) != NULL) {
233 CloseHandle(filemap);
234 } else if (!do_config()) {
241 * If the hostname starts with "telnet:", set the
242 * protocol to Telnet and process the string as a
245 if (!strncmp(q, "telnet:", 7)) {
249 if (q[0] == '/' && q[1] == '/')
251 cfg.protocol = PROT_TELNET;
253 while (*p && *p != ':' && *p != '/') p++;
261 strncpy (cfg.host, q, sizeof(cfg.host)-1);
262 cfg.host[sizeof(cfg.host)-1] = '\0';
264 while (*p && !isspace(*p)) p++;
267 strncpy (cfg.host, q, sizeof(cfg.host)-1);
268 cfg.host[sizeof(cfg.host)-1] = '\0';
269 while (*p && isspace(*p)) p++;
282 /* See if host is of the form user@host */
283 if (cfg.host[0] != '\0') {
284 char *atsign = strchr(cfg.host, '@');
285 /* Make sure we're not overflowing the user field */
287 if (atsign-cfg.host < sizeof cfg.username) {
288 strncpy (cfg.username, cfg.host, atsign-cfg.host);
289 cfg.username[atsign-cfg.host] = '\0';
291 memmove(cfg.host, atsign+1, 1+strlen(atsign+1));
297 * Select protocol. This is farmed out into a table in a
298 * separate file to enable an ssh-free variant.
303 for (i = 0; backends[i].backend != NULL; i++)
304 if (backends[i].protocol == cfg.protocol) {
305 back = backends[i].backend;
309 MessageBox(NULL, "Unsupported protocol number found",
310 "PuTTY Internal Error", MB_OK | MB_ICONEXCLAMATION);
316 real_ldisc = (cfg.ldisc_term ? &ldisc_term : &ldisc_simple);
317 /* To start with, we use the simple line discipline, so we can
318 * type passwords etc without fear of them being echoed... */
319 ldisc = &ldisc_simple;
323 wndclass.lpfnWndProc = WndProc;
324 wndclass.cbClsExtra = 0;
325 wndclass.cbWndExtra = 0;
326 wndclass.hInstance = inst;
327 wndclass.hIcon = LoadIcon (inst,
328 MAKEINTRESOURCE(IDI_MAINICON));
329 wndclass.hCursor = LoadCursor (NULL, IDC_IBEAM);
330 wndclass.hbrBackground = GetStockObject (BLACK_BRUSH);
331 wndclass.lpszMenuName = NULL;
332 wndclass.lpszClassName = appname;
334 RegisterClass (&wndclass);
339 savelines = cfg.savelines;
345 * Guess some defaults for the window size. This all gets
346 * updated later, so we don't really care too much. However, we
347 * do want the font width/height guesses to correspond to a
348 * large font rather than a small one...
355 term_size (cfg.height, cfg.width, cfg.savelines);
356 guess_width = extra_width + font_width * cols;
357 guess_height = extra_height + font_height * rows;
360 HWND w = GetDesktopWindow();
361 GetWindowRect (w, &r);
362 if (guess_width > r.right - r.left)
363 guess_width = r.right - r.left;
364 if (guess_height > r.bottom - r.top)
365 guess_height = r.bottom - r.top;
369 int winmode = WS_OVERLAPPEDWINDOW|WS_VSCROLL;
371 if (!cfg.scrollbar) winmode &= ~(WS_VSCROLL);
372 if (cfg.locksize) winmode &= ~(WS_THICKFRAME|WS_MAXIMIZEBOX);
373 if (cfg.alwaysontop) exwinmode = WS_EX_TOPMOST;
374 hwnd = CreateWindowEx (exwinmode, appname, appname,
375 winmode, CW_USEDEFAULT, CW_USEDEFAULT,
376 guess_width, guess_height,
377 NULL, NULL, inst, NULL);
381 * Initialise the fonts, simultaneously correcting the guesses
382 * for font_{width,height}.
384 bold_mode = cfg.bold_colour ? BOLD_COLOURS : BOLD_FONT;
389 * Correct the guesses for extra_{width,height}.
393 GetWindowRect (hwnd, &wr);
394 GetClientRect (hwnd, &cr);
395 extra_width = wr.right - wr.left - cr.right + cr.left;
396 extra_height = wr.bottom - wr.top - cr.bottom + cr.top;
400 * Resize the window, now we know what size we _really_ want it
403 guess_width = extra_width + font_width * cols;
404 guess_height = extra_height + font_height * rows;
405 SendMessage (hwnd, WM_IGNORE_SIZE, 0, 0);
406 SetWindowPos (hwnd, NULL, 0, 0, guess_width, guess_height,
407 SWP_NOMOVE | SWP_NOREDRAW | SWP_NOZORDER);
410 * Set up a caret bitmap, with no content.
414 int size = (font_width+15)/16 * 2 * font_height;
415 bits = calloc(size, 1);
416 caretbm = CreateBitmap(font_width, font_height, 1, 1, bits);
421 * Initialise the scroll bar.
426 si.cbSize = sizeof(si);
427 si.fMask = SIF_ALL | SIF_DISABLENOSCROLL;
432 SetScrollInfo (hwnd, SB_VERT, &si, FALSE);
436 * Start up the telnet connection.
440 char msg[1024], *title;
443 error = back->init (cfg.host, cfg.port, &realhost);
445 sprintf(msg, "Unable to open connection:\n%s", error);
446 MessageBox(NULL, msg, "PuTTY Error", MB_ICONERROR | MB_OK);
449 window_name = icon_name = NULL;
451 title = cfg.wintitle;
453 sprintf(msg, "%s - PuTTY", realhost);
460 session_closed = FALSE;
463 * Set up the input and output buffers.
466 outbuf_reap = outbuf_head = 0;
469 * Prepare the mouse handler.
471 lastact = MA_NOTHING;
472 lastbtn = MB_NOTHING;
473 dbltime = GetDoubleClickTime();
476 * Set up the session-control options on the system menu.
479 HMENU m = GetSystemMenu (hwnd, FALSE);
483 AppendMenu (m, MF_SEPARATOR, 0, 0);
484 if (cfg.protocol == PROT_TELNET) {
486 AppendMenu (p, MF_ENABLED, IDM_TEL_AYT, "Are You There");
487 AppendMenu (p, MF_ENABLED, IDM_TEL_BRK, "Break");
488 AppendMenu (p, MF_ENABLED, IDM_TEL_SYNCH, "Synch");
489 AppendMenu (p, MF_SEPARATOR, 0, 0);
490 AppendMenu (p, MF_ENABLED, IDM_TEL_EC, "Erase Character");
491 AppendMenu (p, MF_ENABLED, IDM_TEL_EL, "Erase Line");
492 AppendMenu (p, MF_ENABLED, IDM_TEL_GA, "Go Ahead");
493 AppendMenu (p, MF_ENABLED, IDM_TEL_NOP, "No Operation");
494 AppendMenu (p, MF_SEPARATOR, 0, 0);
495 AppendMenu (p, MF_ENABLED, IDM_TEL_ABORT, "Abort Process");
496 AppendMenu (p, MF_ENABLED, IDM_TEL_AO, "Abort Output");
497 AppendMenu (p, MF_ENABLED, IDM_TEL_IP, "Interrupt Process");
498 AppendMenu (p, MF_ENABLED, IDM_TEL_SUSP, "Suspend Process");
499 AppendMenu (p, MF_SEPARATOR, 0, 0);
500 AppendMenu (p, MF_ENABLED, IDM_TEL_EOR, "End Of Record");
501 AppendMenu (p, MF_ENABLED, IDM_TEL_EOF, "End Of File");
502 AppendMenu (m, MF_POPUP | MF_ENABLED, (UINT) p, "Telnet Command");
503 AppendMenu (m, MF_SEPARATOR, 0, 0);
505 AppendMenu (m, MF_ENABLED, IDM_SHOWLOG, "&Event Log");
506 AppendMenu (m, MF_SEPARATOR, 0, 0);
507 AppendMenu (m, MF_ENABLED, IDM_NEWSESS, "Ne&w Session...");
508 AppendMenu (m, MF_ENABLED, IDM_DUPSESS, "&Duplicate Session");
511 for (i = 1 ; i < ((nsessions < 256) ? nsessions : 256) ; i++)
512 AppendMenu (s, MF_ENABLED, IDM_SAVED_MIN + (16 * i) , sessions[i]);
513 AppendMenu (m, MF_POPUP | MF_ENABLED, (UINT) s, "Sa&ved Sessions");
514 AppendMenu (m, MF_ENABLED, IDM_RECONF, "Chan&ge Settings...");
515 AppendMenu (m, MF_SEPARATOR, 0, 0);
516 AppendMenu (m, MF_ENABLED, IDM_CLRSB, "C&lear Scrollback");
517 AppendMenu (m, MF_ENABLED, IDM_RESET, "Rese&t Terminal");
518 AppendMenu (m, MF_SEPARATOR, 0, 0);
519 AppendMenu (m, MF_ENABLED, IDM_ABOUT, "&About PuTTY");
523 * Finally show the window!
525 ShowWindow (hwnd, show);
528 * Set the palette up.
534 has_focus = (GetForegroundWindow() == hwnd);
537 if (GetMessage (&msg, NULL, 0, 0) == 1)
539 int timer_id = 0, long_timer = 0;
541 while (msg.message != WM_QUIT) {
542 /* Sometimes DispatchMessage calls routines that use their own
543 * GetMessage loop, setup this timer so we get some control back.
545 * Also call term_update() from the timer so that if the host
546 * is sending data flat out we still do redraws.
548 if(timer_id && long_timer) {
549 KillTimer(hwnd, timer_id);
550 long_timer = timer_id = 0;
553 timer_id = SetTimer(hwnd, 1, 20, NULL);
554 DispatchMessage (&msg);
556 /* Make sure we blink everything that needs it. */
559 /* Send the paste buffer if there's anything to send */
562 /* If there's nothing new in the queue then we can do everything
563 * we've delayed, reading the socket, writing, and repainting
566 if (PeekMessage (&msg, NULL, 0, 0, PM_REMOVE))
569 if (pending_netevent) {
570 enact_pending_netevent();
572 /* Force the cursor blink on */
575 if (PeekMessage (&msg, NULL, 0, 0, PM_REMOVE))
579 /* Okay there is now nothing to do so we make sure the screen is
580 * completely up to date then tell windows to call us in a little
584 KillTimer(hwnd, timer_id);
593 timer_id = SetTimer(hwnd, 1, 59500, NULL);
595 timer_id = SetTimer(hwnd, 1, 250, NULL);
598 /* There's no point rescanning everything in the message queue
599 * so we do an apperently unneccesary wait here
602 if (GetMessage (&msg, NULL, 0, 0) != 1)
614 DeleteObject(fonts[i]);
621 if (cfg.protocol == PROT_SSH) {
632 * Set up, or shut down, an AsyncSelect. Called from winnet.c.
634 char *do_select(SOCKET skt, int startup) {
638 events = FD_READ | FD_WRITE | FD_OOB | FD_CLOSE;
643 return "do_select(): internal error (hwnd==NULL)";
644 if (WSAAsyncSelect (skt, hwnd, msg, events) == SOCKET_ERROR) {
645 switch (WSAGetLastError()) {
646 case WSAENETDOWN: return "Network is down";
647 default: return "WSAAsyncSelect(): unknown error";
654 * Print a message box and close the connection.
656 void connection_fatal(char *fmt, ...) {
661 vsprintf(stuff, fmt, ap);
663 MessageBox(hwnd, stuff, "PuTTY Fatal Error", MB_ICONERROR | MB_OK);
664 if (cfg.close_on_exit)
667 session_closed = TRUE;
668 SetWindowText (hwnd, "PuTTY (inactive)");
673 * Actually do the job requested by a WM_NETEVENT
675 static void enact_pending_netevent(void) {
676 static int reentering = 0;
677 extern int select_result(WPARAM, LPARAM);
681 return; /* don't unpend the pending */
683 pending_netevent = FALSE;
686 ret = select_result (pend_netevent_wParam, pend_netevent_lParam);
690 if (cfg.close_on_exit)
693 session_closed = TRUE;
694 MessageBox(hwnd, "Connection closed by remote host",
695 "PuTTY", MB_OK | MB_ICONINFORMATION);
696 SetWindowText (hwnd, "PuTTY (inactive)");
702 * Copy the colour palette from the configuration data into defpal.
703 * This is non-trivial because the colour indices are different.
705 static void cfgtopalette(void) {
707 static const int ww[] = {
708 6, 7, 8, 9, 10, 11, 12, 13,
709 14, 15, 16, 17, 18, 19, 20, 21,
710 0, 1, 2, 3, 4, 4, 5, 5
713 for (i=0; i<24; i++) {
715 defpal[i].rgbtRed = cfg.colours[w][0];
716 defpal[i].rgbtGreen = cfg.colours[w][1];
717 defpal[i].rgbtBlue = cfg.colours[w][2];
722 * Set up the colour palette.
724 static void init_palette(void) {
726 HDC hdc = GetDC (hwnd);
728 if (cfg.try_palette &&
729 GetDeviceCaps (hdc, RASTERCAPS) & RC_PALETTE) {
730 logpal = smalloc(sizeof(*logpal)
731 - sizeof(logpal->palPalEntry)
732 + NCOLOURS * sizeof(PALETTEENTRY));
733 logpal->palVersion = 0x300;
734 logpal->palNumEntries = NCOLOURS;
735 for (i = 0; i < NCOLOURS; i++) {
736 logpal->palPalEntry[i].peRed = defpal[i].rgbtRed;
737 logpal->palPalEntry[i].peGreen = defpal[i].rgbtGreen;
738 logpal->palPalEntry[i].peBlue = defpal[i].rgbtBlue;
739 logpal->palPalEntry[i].peFlags = PC_NOCOLLAPSE;
741 pal = CreatePalette (logpal);
743 SelectPalette (hdc, pal, FALSE);
744 RealizePalette (hdc);
745 SelectPalette (hdc, GetStockObject (DEFAULT_PALETTE),
749 ReleaseDC (hwnd, hdc);
752 for (i=0; i<NCOLOURS; i++)
753 colours[i] = PALETTERGB(defpal[i].rgbtRed,
757 for(i=0; i<NCOLOURS; i++)
758 colours[i] = RGB(defpal[i].rgbtRed,
764 * Initialise all the fonts we will need. There may be as many as
765 * eight or as few as one. We also:
767 * - check the font width and height, correcting our guesses if
770 * - verify that the bold font is the same width as the ordinary
771 * one, and engage shadow bolding if not.
773 * - verify that the underlined font is the same width as the
774 * ordinary one (manual underlining by means of line drawing can
775 * be done in a pinch).
777 static void init_fonts(int pick_width) {
782 int fw_dontcare, fw_bold;
791 if (cfg.fontisbold) {
792 fw_dontcare = FW_BOLD;
795 fw_dontcare = FW_DONTCARE;
801 font_height = cfg.fontheight;
802 font_width = pick_width;
805 fonts[i] = CreateFont (font_height, font_width, 0, 0, w, FALSE, u, FALSE, \
806 c, OUT_DEFAULT_PRECIS, \
807 CLIP_DEFAULT_PRECIS, DEFAULT_QUALITY, \
808 FIXED_PITCH | FF_DONTCARE, cfg.font)
810 if (cfg.vtmode != VT_OEMONLY) {
811 f(FONT_NORMAL, cfg.fontcharset, fw_dontcare, FALSE);
813 SelectObject (hdc, fonts[FONT_NORMAL]);
814 GetTextMetrics(hdc, &tm);
815 font_height = tm.tmHeight;
816 font_width = tm.tmAveCharWidth;
818 f(FONT_UNDERLINE, cfg.fontcharset, fw_dontcare, TRUE);
821 * Some fonts, e.g. 9-pt Courier, draw their underlines
822 * outside their character cell. We successfully prevent
823 * screen corruption by clipping the text output, but then
824 * we lose the underline completely. Here we try to work
825 * out whether this is such a font, and if it is, we set a
826 * flag that causes underlines to be drawn by hand.
828 * Having tried other more sophisticated approaches (such
829 * as examining the TEXTMETRIC structure or requesting the
830 * height of a string), I think we'll do this the brute
831 * force way: we create a small bitmap, draw an underlined
832 * space on it, and test to see whether any pixels are
833 * foreground-coloured. (Since we expect the underline to
834 * go all the way across the character cell, we only search
835 * down a single column of the bitmap, half way across.)
839 HBITMAP und_bm, und_oldbm;
843 und_dc = CreateCompatibleDC(hdc);
844 und_bm = CreateCompatibleBitmap(hdc, font_width, font_height);
845 und_oldbm = SelectObject(und_dc, und_bm);
846 SelectObject(und_dc, fonts[FONT_UNDERLINE]);
847 SetTextAlign(und_dc, TA_TOP | TA_LEFT | TA_NOUPDATECP);
848 SetTextColor (und_dc, RGB(255,255,255));
849 SetBkColor (und_dc, RGB(0,0,0));
850 SetBkMode (und_dc, OPAQUE);
851 ExtTextOut (und_dc, 0, 0, ETO_OPAQUE, NULL, " ", 1, NULL);
853 for (i = 0; i < font_height; i++) {
854 c = GetPixel(und_dc, font_width/2, i);
858 SelectObject(und_dc, und_oldbm);
859 DeleteObject(und_bm);
861 font_needs_hand_underlining = !gotit;
864 if (bold_mode == BOLD_FONT) {
865 f(FONT_BOLD, cfg.fontcharset, fw_bold, FALSE);
866 f(FONT_BOLDUND, cfg.fontcharset, fw_bold, TRUE);
869 if (cfg.vtmode == VT_OEMANSI) {
870 f(FONT_OEM, OEM_CHARSET, fw_dontcare, FALSE);
871 f(FONT_OEMUND, OEM_CHARSET, fw_dontcare, TRUE);
873 if (bold_mode == BOLD_FONT) {
874 f(FONT_OEMBOLD, OEM_CHARSET, fw_bold, FALSE);
875 f(FONT_OEMBOLDUND, OEM_CHARSET, fw_bold, TRUE);
881 f(FONT_OEM, cfg.fontcharset, fw_dontcare, FALSE);
883 SelectObject (hdc, fonts[FONT_OEM]);
884 GetTextMetrics(hdc, &tm);
885 font_height = tm.tmHeight;
886 font_width = tm.tmAveCharWidth;
888 f(FONT_OEMUND, cfg.fontcharset, fw_dontcare, TRUE);
890 if (bold_mode == BOLD_FONT) {
891 f(FONT_BOLD, cfg.fontcharset, fw_bold, FALSE);
892 f(FONT_BOLDUND, cfg.fontcharset, fw_bold, TRUE);
897 descent = tm.tmAscent + 1;
898 if (descent >= font_height)
899 descent = font_height - 1;
900 firstchar = tm.tmFirstChar;
902 for (i=0; i<8; i++) {
904 if (SelectObject (hdc, fonts[i]) &&
905 GetTextMetrics(hdc, &tm) )
906 fsize[i] = tm.tmAveCharWidth + 256 * tm.tmHeight;
912 ReleaseDC (hwnd, hdc);
914 /* ... This is wrong in OEM only mode */
915 if (fsize[FONT_UNDERLINE] != fsize[FONT_NORMAL] ||
916 (bold_mode == BOLD_FONT &&
917 fsize[FONT_BOLDUND] != fsize[FONT_BOLD])) {
919 DeleteObject (fonts[FONT_UNDERLINE]);
920 if (bold_mode == BOLD_FONT)
921 DeleteObject (fonts[FONT_BOLDUND]);
924 if (bold_mode == BOLD_FONT &&
925 fsize[FONT_BOLD] != fsize[FONT_NORMAL]) {
926 bold_mode = BOLD_SHADOW;
927 DeleteObject (fonts[FONT_BOLD]);
928 if (und_mode == UND_FONT)
929 DeleteObject (fonts[FONT_BOLDUND]);
933 /* With the fascist font painting it doesn't matter if the linedraw font
934 * isn't exactly the right size anymore so we don't have to check this.
936 if (cfg.vtmode == VT_OEMANSI && fsize[FONT_OEM] != fsize[FONT_NORMAL] ) {
937 if( cfg.fontcharset == OEM_CHARSET )
939 MessageBox(NULL, "The OEM and ANSI versions of this font are\n"
940 "different sizes. Using OEM-only mode instead",
941 "Font Size Mismatch", MB_ICONINFORMATION | MB_OK);
942 cfg.vtmode = VT_OEMONLY;
944 else if( firstchar < ' ' )
946 MessageBox(NULL, "The OEM and ANSI versions of this font are\n"
947 "different sizes. Using XTerm mode instead",
948 "Font Size Mismatch", MB_ICONINFORMATION | MB_OK);
949 cfg.vtmode = VT_XWINDOWS;
953 MessageBox(NULL, "The OEM and ANSI versions of this font are\n"
954 "different sizes. Using ISO8859-1 mode instead",
955 "Font Size Mismatch", MB_ICONINFORMATION | MB_OK);
956 cfg.vtmode = VT_POORMAN;
961 DeleteObject (fonts[i]);
967 void request_resize (int w, int h, int refont) {
970 /* If the window is maximized supress resizing attempts */
971 if(IsZoomed(hwnd)) return;
974 /* Don't do this in OEMANSI, you may get disable messages */
975 if (refont && w != cols && (cols==80 || cols==132)
976 && cfg.vtmode != VT_OEMANSI)
978 if (refont && w != cols && (cols==80 || cols==132))
981 /* If font width too big for screen should we shrink the font more ? */
983 font_width = ((font_width*cols+w/2)/w);
990 DeleteObject(fonts[i]);
992 bold_mode = cfg.bold_colour ? BOLD_COLOURS : BOLD_FONT;
994 init_fonts(font_width);
998 static int first_time = 1;
1004 /* Get the size of the screen */
1005 if (GetClientRect(GetDesktopWindow(),&ss))
1006 /* first_time = 0 */;
1007 else { first_time = 2; break; }
1009 /* Make sure the values are sane */
1010 width = (ss.right-ss.left-extra_width ) / font_width;
1011 height = (ss.bottom-ss.top-extra_height ) / font_height;
1013 if (w>width) w=width;
1014 if (h>height) h=height;
1020 width = extra_width + font_width * w;
1021 height = extra_height + font_height * h;
1023 SetWindowPos (hwnd, NULL, 0, 0, width, height,
1024 SWP_NOACTIVATE | SWP_NOCOPYBITS |
1025 SWP_NOMOVE | SWP_NOZORDER);
1028 static void click (Mouse_Button b, int x, int y) {
1029 int thistime = GetMessageTime();
1031 if (lastbtn == b && thistime - lasttime < dbltime) {
1032 lastact = (lastact == MA_CLICK ? MA_2CLK :
1033 lastact == MA_2CLK ? MA_3CLK :
1034 lastact == MA_3CLK ? MA_CLICK : MA_NOTHING);
1039 if (lastact != MA_NOTHING)
1040 term_mouse (b, lastact, x, y);
1041 lasttime = thistime;
1044 static LRESULT CALLBACK WndProc (HWND hwnd, UINT message,
1045 WPARAM wParam, LPARAM lParam) {
1047 static int ignore_size = FALSE;
1048 static int ignore_clip = FALSE;
1049 static int just_reconfigged = FALSE;
1050 static int resizing = FALSE;
1054 if (pending_netevent)
1055 enact_pending_netevent();
1062 if (cfg.ping_interval > 0)
1066 if (now-last_movement > cfg.ping_interval * 60 - 10)
1068 back->special(TS_PING);
1069 last_movement = now;
1076 if (!cfg.warn_on_close || session_closed ||
1077 MessageBox(hwnd, "Are you sure you want to close this session?",
1078 "PuTTY Exit Confirmation",
1079 MB_ICONWARNING | MB_OKCANCEL) == IDOK)
1080 DestroyWindow(hwnd);
1083 PostQuitMessage (0);
1086 switch (wParam & ~0xF) { /* low 4 bits reserved to Windows */
1098 PROCESS_INFORMATION pi;
1099 HANDLE filemap = NULL;
1101 if (wParam == IDM_DUPSESS) {
1103 * Allocate a file-mapping memory chunk for the
1106 SECURITY_ATTRIBUTES sa;
1109 sa.nLength = sizeof(sa);
1110 sa.lpSecurityDescriptor = NULL;
1111 sa.bInheritHandle = TRUE;
1112 filemap = CreateFileMapping((HANDLE)0xFFFFFFFF,
1119 p = (Config *)MapViewOfFile(filemap,
1121 0, 0, sizeof(Config));
1123 *p = cfg; /* structure copy */
1127 sprintf(c, "putty &%p", filemap);
1129 } else if (wParam == IDM_SAVEDSESS) {
1130 char *session = sessions[(lParam - IDM_SAVED_MIN) / 16];
1131 cl = malloc(16 + strlen(session)); /* 8, but play safe */
1133 cl = NULL; /* not a very important failure mode */
1135 sprintf(cl, "putty @%s", session);
1141 GetModuleFileName (NULL, b, sizeof(b)-1);
1143 si.lpReserved = NULL;
1144 si.lpDesktop = NULL;
1148 si.lpReserved2 = NULL;
1149 CreateProcess (b, cl, NULL, NULL, TRUE,
1150 NORMAL_PRIORITY_CLASS, NULL, NULL, &si, &pi);
1153 CloseHandle(filemap);
1160 int prev_alwaysontop = cfg.alwaysontop;
1161 if (!do_reconfig(hwnd))
1163 just_reconfigged = TRUE;
1168 DeleteObject(fonts[i]);
1170 bold_mode = cfg.bold_colour ? BOLD_COLOURS : BOLD_FONT;
1171 und_mode = UND_FONT;
1175 * Telnet will change local echo -> remote if the
1178 if (cfg.protocol != PROT_TELNET)
1179 ldisc = (cfg.ldisc_term ? &ldisc_term : &ldisc_simple);
1187 /* Enable or disable the scroll bar, etc */
1189 LONG nflg, flag = GetWindowLong(hwnd, GWL_STYLE);
1190 LONG nexflag, exflag = GetWindowLong(hwnd, GWL_EXSTYLE);
1193 if (cfg.alwaysontop != prev_alwaysontop) {
1194 if (cfg.alwaysontop) {
1195 nexflag = WS_EX_TOPMOST;
1196 SetWindowPos(hwnd, HWND_TOPMOST, 0, 0, 0, 0,
1197 SWP_NOMOVE | SWP_NOSIZE);
1200 SetWindowPos(hwnd, HWND_NOTOPMOST, 0, 0, 0, 0,
1201 SWP_NOMOVE | SWP_NOSIZE);
1206 if (cfg.scrollbar) nflg |= WS_VSCROLL;
1207 else nflg &= ~WS_VSCROLL;
1209 nflg &= ~(WS_THICKFRAME|WS_MAXIMIZEBOX);
1211 nflg |= (WS_THICKFRAME|WS_MAXIMIZEBOX);
1213 if (nflg != flag || nexflag != exflag)
1218 SetWindowLong(hwnd, GWL_STYLE, nflg);
1219 if (nexflag != exflag)
1220 SetWindowLong(hwnd, GWL_EXSTYLE, nexflag);
1222 SendMessage (hwnd, WM_IGNORE_SIZE, 0, 0);
1223 SetWindowPos(hwnd, NULL, 0,0,0,0,
1224 SWP_NOACTIVATE|SWP_NOCOPYBITS|
1225 SWP_NOMOVE|SWP_NOSIZE|SWP_NOZORDER|
1228 GetWindowRect (hwnd, &wr);
1229 GetClientRect (hwnd, &cr);
1230 extra_width = wr.right - wr.left - cr.right + cr.left;
1231 extra_height = wr.bottom - wr.top - cr.bottom + cr.top;
1235 term_size(cfg.height, cfg.width, cfg.savelines);
1236 InvalidateRect(hwnd, NULL, TRUE);
1237 SetWindowPos (hwnd, NULL, 0, 0,
1238 extra_width + font_width * cfg.width,
1239 extra_height + font_height * cfg.height,
1240 SWP_NOACTIVATE | SWP_NOCOPYBITS |
1241 SWP_NOMOVE | SWP_NOZORDER);
1242 if (IsIconic(hwnd)) {
1243 SetWindowText (hwnd,
1244 cfg.win_name_always ? window_name : icon_name);
1254 case IDM_TEL_AYT: back->special (TS_AYT); break;
1255 case IDM_TEL_BRK: back->special (TS_BRK); break;
1256 case IDM_TEL_SYNCH: back->special (TS_SYNCH); break;
1257 case IDM_TEL_EC: back->special (TS_EC); break;
1258 case IDM_TEL_EL: back->special (TS_EL); break;
1259 case IDM_TEL_GA: back->special (TS_GA); break;
1260 case IDM_TEL_NOP: back->special (TS_NOP); break;
1261 case IDM_TEL_ABORT: back->special (TS_ABORT); break;
1262 case IDM_TEL_AO: back->special (TS_AO); break;
1263 case IDM_TEL_IP: back->special (TS_IP); break;
1264 case IDM_TEL_SUSP: back->special (TS_SUSP); break;
1265 case IDM_TEL_EOR: back->special (TS_EOR); break;
1266 case IDM_TEL_EOF: back->special (TS_EOF); break;
1271 if (wParam >= IDM_SAVED_MIN && wParam <= IDM_SAVED_MAX) {
1272 SendMessage(hwnd, WM_SYSCOMMAND, IDM_SAVEDSESS, wParam);
1277 #define X_POS(l) ((int)(short)LOWORD(l))
1278 #define Y_POS(l) ((int)(short)HIWORD(l))
1280 #define TO_CHR_X(x) (((x)<0 ? (x)-font_width+1 : (x)) / font_width)
1281 #define TO_CHR_Y(y) (((y)<0 ? (y)-font_height+1: (y)) / font_height)
1283 case WM_LBUTTONDOWN:
1284 click (MB_SELECT, TO_CHR_X(X_POS(lParam)),
1285 TO_CHR_Y(Y_POS(lParam)));
1289 term_mouse (MB_SELECT, MA_RELEASE, TO_CHR_X(X_POS(lParam)),
1290 TO_CHR_Y(Y_POS(lParam)));
1293 case WM_MBUTTONDOWN:
1295 click (cfg.mouse_is_xterm ? MB_PASTE : MB_EXTEND,
1296 TO_CHR_X(X_POS(lParam)),
1297 TO_CHR_Y(Y_POS(lParam)));
1300 term_mouse (cfg.mouse_is_xterm ? MB_PASTE : MB_EXTEND,
1301 MA_RELEASE, TO_CHR_X(X_POS(lParam)),
1302 TO_CHR_Y(Y_POS(lParam)));
1305 case WM_RBUTTONDOWN:
1307 click (cfg.mouse_is_xterm ? MB_EXTEND : MB_PASTE,
1308 TO_CHR_X(X_POS(lParam)),
1309 TO_CHR_Y(Y_POS(lParam)));
1312 term_mouse (cfg.mouse_is_xterm ? MB_EXTEND : MB_PASTE,
1313 MA_RELEASE, TO_CHR_X(X_POS(lParam)),
1314 TO_CHR_Y(Y_POS(lParam)));
1319 * Add the mouse position and message time to the random
1322 noise_ultralight(lParam);
1324 if (wParam & (MK_LBUTTON | MK_MBUTTON | MK_RBUTTON)) {
1326 if (wParam & MK_LBUTTON)
1328 else if (wParam & MK_MBUTTON)
1329 b = cfg.mouse_is_xterm ? MB_PASTE : MB_EXTEND;
1331 b = cfg.mouse_is_xterm ? MB_EXTEND : MB_PASTE;
1332 term_mouse (b, MA_DRAG, TO_CHR_X(X_POS(lParam)),
1333 TO_CHR_Y(Y_POS(lParam)));
1336 case WM_IGNORE_CLIP:
1337 ignore_clip = wParam; /* don't panic on DESTROYCLIPBOARD */
1339 case WM_DESTROYCLIPBOARD:
1342 ignore_clip = FALSE;
1348 hdc = BeginPaint (hwnd, &p);
1350 SelectPalette (hdc, pal, TRUE);
1351 RealizePalette (hdc);
1353 term_paint (hdc, p.rcPaint.left, p.rcPaint.top,
1354 p.rcPaint.right, p.rcPaint.bottom);
1355 SelectObject (hdc, GetStockObject(SYSTEM_FONT));
1356 SelectObject (hdc, GetStockObject(WHITE_PEN));
1357 EndPaint (hwnd, &p);
1362 /* Notice we can get multiple netevents, FD_READ, FD_WRITE etc
1363 * but the only one that's likely to try to overload us is FD_READ.
1364 * This means buffering just one is fine.
1366 if (pending_netevent)
1367 enact_pending_netevent();
1369 pending_netevent = TRUE;
1370 pend_netevent_wParam=wParam;
1371 pend_netevent_lParam=lParam;
1372 time(&last_movement);
1376 CreateCaret(hwnd, caretbm, 0, 0);
1388 case WM_IGNORE_SIZE:
1389 ignore_size = TRUE; /* don't panic on next WM_SIZE msg */
1391 case WM_ENTERSIZEMOVE:
1395 case WM_EXITSIZEMOVE:
1402 int width, height, w, h, ew, eh;
1403 LPRECT r = (LPRECT)lParam;
1405 width = r->right - r->left - extra_width;
1406 height = r->bottom - r->top - extra_height;
1407 w = (width + font_width/2) / font_width; if (w < 1) w = 1;
1408 h = (height + font_height/2) / font_height; if (h < 1) h = 1;
1409 UpdateSizeTip(hwnd, w, h);
1410 ew = width - w * font_width;
1411 eh = height - h * font_height;
1413 if (wParam == WMSZ_LEFT ||
1414 wParam == WMSZ_BOTTOMLEFT ||
1415 wParam == WMSZ_TOPLEFT)
1421 if (wParam == WMSZ_TOP ||
1422 wParam == WMSZ_TOPRIGHT ||
1423 wParam == WMSZ_TOPLEFT)
1433 /* break; (never reached) */
1435 if (wParam == SIZE_MINIMIZED) {
1436 SetWindowText (hwnd,
1437 cfg.win_name_always ? window_name : icon_name);
1440 if (wParam == SIZE_RESTORED || wParam == SIZE_MAXIMIZED)
1441 SetWindowText (hwnd, window_name);
1443 int width, height, w, h;
1444 #if 0 /* we have fixed this using WM_SIZING now */
1448 width = LOWORD(lParam);
1449 height = HIWORD(lParam);
1450 w = width / font_width; if (w < 1) w = 1;
1451 h = height / font_height; if (h < 1) h = 1;
1452 #if 0 /* we have fixed this using WM_SIZING now */
1453 ew = width - w * font_width;
1454 eh = height - h * font_height;
1455 if (ew != 0 || eh != 0) {
1457 GetWindowRect (hwnd, &r);
1458 SendMessage (hwnd, WM_IGNORE_SIZE, 0, 0);
1459 SetWindowPos (hwnd, NULL, 0, 0,
1460 r.right - r.left - ew, r.bottom - r.top - eh,
1461 SWP_NOACTIVATE | SWP_NOMOVE | SWP_NOZORDER);
1464 if (w != cols || h != rows || just_reconfigged) {
1466 term_size (h, w, cfg.savelines);
1468 * Don't call back->size in mid-resize. (To prevent
1469 * massive numbers of resize events getting sent
1470 * down the connection during an NT opaque drag.)
1474 just_reconfigged = FALSE;
1477 ignore_size = FALSE;
1480 switch (LOWORD(wParam)) {
1481 case SB_BOTTOM: term_scroll(-1, 0); break;
1482 case SB_TOP: term_scroll(+1, 0); break;
1483 case SB_LINEDOWN: term_scroll (0, +1); break;
1484 case SB_LINEUP: term_scroll (0, -1); break;
1485 case SB_PAGEDOWN: term_scroll (0, +rows/2); break;
1486 case SB_PAGEUP: term_scroll (0, -rows/2); break;
1487 case SB_THUMBPOSITION: case SB_THUMBTRACK:
1488 term_scroll (1, HIWORD(wParam)); break;
1491 case WM_PALETTECHANGED:
1492 if ((HWND) wParam != hwnd && pal != NULL) {
1493 HDC hdc = get_ctx();
1495 if (RealizePalette (hdc) > 0)
1501 case WM_QUERYNEWPALETTE:
1503 HDC hdc = get_ctx();
1505 if (RealizePalette (hdc) > 0)
1517 * Add the scan code and keypress timing to the random
1520 noise_ultralight(lParam);
1523 * We don't do TranslateMessage since it disassociates the
1524 * resulting CHAR message from the KEYDOWN that sparked it,
1525 * which we occasionally don't want. Instead, we process
1526 * KEYDOWN, and call the Win32 translator functions so that
1527 * we get the translations under _our_ control.
1530 unsigned char buf[20];
1533 if (wParam==VK_PROCESSKEY) {
1536 m.message = WM_KEYDOWN;
1538 m.lParam = lParam & 0xdfff;
1539 TranslateMessage(&m);
1541 len = TranslateKey (message, wParam, lParam, buf);
1543 return DefWindowProc (hwnd, message, wParam, lParam);
1544 ldisc->send (buf, len);
1550 unsigned char buf[2];
1553 buf[0] = wParam >> 8;
1554 ldisc->send (buf, 2);
1559 * Nevertheless, we are prepared to deal with WM_CHAR
1560 * messages, should they crop up. So if someone wants to
1561 * post the things to us as part of a macro manoeuvre,
1562 * we're ready to cope.
1565 char c = xlat_kbd2tty((unsigned char)wParam);
1566 ldisc->send (&c, 1);
1571 return DefWindowProc (hwnd, message, wParam, lParam);
1575 * Move the system caret. (We maintain one, even though it's
1576 * invisible, for the benefit of blind people: apparently some
1577 * helper software tracks the system caret, so we should arrange to
1580 void sys_cursor(int x, int y) {
1581 SetCaretPos(x * font_width, y * font_height);
1585 * Draw a line of text in the window, at given character
1586 * coordinates, in given attributes.
1588 * We are allowed to fiddle with the contents of `text'.
1590 void do_text (Context ctx, int x, int y, char *text, int len,
1591 unsigned long attr, int lattr) {
1593 int nfg, nbg, nfont;
1596 int force_manual_underline = 0;
1597 int fnt_width = font_width*(1+(lattr!=LATTR_NORM));
1598 static int *IpDx = 0, IpDxLEN = 0;;
1600 if (len>IpDxLEN || IpDx[0] != fnt_width) {
1604 IpDx = smalloc((len+16)*sizeof(int));
1607 for(i=0; i<IpDxLEN; i++)
1608 IpDx[i] = fnt_width;
1614 if (attr & ATTR_ACTCURS) {
1615 attr &= (bold_mode == BOLD_COLOURS ? 0x300200 : 0x300300);
1616 attr ^= ATTR_CUR_XOR;
1620 if (cfg.vtmode == VT_OEMONLY)
1624 * Map high-half characters in order to approximate ISO using
1625 * OEM character set. No characters are missing if the OEM codepage
1628 if (nfont & FONT_OEM) {
1630 for (i=0; i<len; i++)
1631 if (text[i] >= '\xA0' && text[i] <= '\xFF') {
1633 /* This is CP850 ... perfect translation */
1634 static const char oemhighhalf[] =
1635 "\x20\xAD\xBD\x9C\xCF\xBE\xDD\xF5" /* A0-A7 */
1636 "\xF9\xB8\xA6\xAE\xAA\xF0\xA9\xEE" /* A8-AF */
1637 "\xF8\xF1\xFD\xFC\xEF\xE6\xF4\xFA" /* B0-B7 */
1638 "\xF7\xFB\xA7\xAF\xAC\xAB\xF3\xA8" /* B8-BF */
1639 "\xB7\xB5\xB6\xC7\x8E\x8F\x92\x80" /* C0-C7 */
1640 "\xD4\x90\xD2\xD3\xDE\xD6\xD7\xD8" /* C8-CF */
1641 "\xD1\xA5\xE3\xE0\xE2\xE5\x99\x9E" /* D0-D7 */
1642 "\x9D\xEB\xE9\xEA\x9A\xED\xE8\xE1" /* D8-DF */
1643 "\x85\xA0\x83\xC6\x84\x86\x91\x87" /* E0-E7 */
1644 "\x8A\x82\x88\x89\x8D\xA1\x8C\x8B" /* E8-EF */
1645 "\xD0\xA4\x95\xA2\x93\xE4\x94\xF6" /* F0-F7 */
1646 "\x9B\x97\xA3\x96\x81\xEC\xE7\x98" /* F8-FF */
1649 /* This is CP437 ... junk translation */
1650 static const unsigned char oemhighhalf[] = {
1651 0xff, 0xad, 0x9b, 0x9c, 0x6f, 0x9d, 0x7c, 0x15,
1652 0x22, 0x43, 0xa6, 0xae, 0xaa, 0x2d, 0x52, 0xc4,
1653 0xf8, 0xf1, 0xfd, 0x33, 0x27, 0xe6, 0x14, 0xfa,
1654 0x2c, 0x31, 0xa7, 0xaf, 0xac, 0xab, 0x2f, 0xa8,
1655 0x41, 0x41, 0x41, 0x41, 0x8e, 0x8f, 0x92, 0x80,
1656 0x45, 0x90, 0x45, 0x45, 0x49, 0x49, 0x49, 0x49,
1657 0x44, 0xa5, 0x4f, 0x4f, 0x4f, 0x4f, 0x99, 0x78,
1658 0xed, 0x55, 0x55, 0x55, 0x9a, 0x59, 0x50, 0xe1,
1659 0x85, 0xa0, 0x83, 0x61, 0x84, 0x86, 0x91, 0x87,
1660 0x8a, 0x82, 0x88, 0x89, 0x8d, 0xa1, 0x8c, 0x8b,
1661 0x0b, 0xa4, 0x95, 0xa2, 0x93, 0x6f, 0x94, 0xf6,
1662 0xed, 0x97, 0xa3, 0x96, 0x81, 0x79, 0x70, 0x98
1665 text[i] = oemhighhalf[(unsigned char)text[i] - 0xA0];
1669 if (attr & ATTR_LINEDRW) {
1672 static const char poorman[] =
1673 "*#****\xB0\xB1**+++++-----++++|****\xA3\xB7";
1676 static const char oemmap_437[] =
1677 "\x04\xB1****\xF8\xF1**\xD9\xBF\xDA\xC0\xC5"
1678 "\xC4\xC4\xC4\xC4\xC4\xC3\xB4\xC1\xC2\xB3\xF3\xF2\xE3*\x9C\xFA";
1681 static const char oemmap_850[] =
1682 "\x04\xB1****\xF8\xF1**\xD9\xBF\xDA\xC0\xC5"
1683 "\xC4\xC4\xC4\xC4\xC4\xC3\xB4\xC1\xC2\xB3****\x9C\xFA";
1685 /* Poor windows font ... eg: windows courier */
1686 static const char oemmap[] =
1687 "*\xB1****\xF8\xF1**\xD9\xBF\xDA\xC0\xC5"
1688 "\xC4\xC4\xC4\xC4\xC4\xC3\xB4\xC1\xC2\xB3****\x9C\xFA";
1691 * Line drawing mapping: map ` thru ~ (0x60 thru 0x7E) to
1692 * VT100 line drawing chars; everything else stays normal.
1694 * Actually '_' maps to space too, but that's done before.
1696 switch (cfg.vtmode) {
1698 for (i=0; i<len; i++)
1699 if (text[i] >= '\x60' && text[i] <= '\x7E')
1700 text[i] += '\x01' - '\x60';
1703 /* Make sure we actually have an OEM font */
1704 if (fonts[nfont|FONT_OEM]) {
1707 for (i=0; i<len; i++)
1708 if (text[i] >= '\x60' && text[i] <= '\x7E')
1709 text[i] = oemmap[(unsigned char)text[i] - 0x60];
1713 for (i=0; i<len; i++)
1714 if (text[i] >= '\x60' && text[i] <= '\x7E')
1715 text[i] = poorman[(unsigned char)text[i] - 0x60];
1720 nfg = 2 * ((attr & ATTR_FGMASK) >> ATTR_FGSHIFT);
1721 nbg = 2 * ((attr & ATTR_BGMASK) >> ATTR_BGSHIFT);
1722 if (bold_mode == BOLD_FONT && (attr & ATTR_BOLD))
1724 if (und_mode == UND_FONT && (attr & ATTR_UNDER))
1725 nfont |= FONT_UNDERLINE;
1728 if (nfont&FONT_UNDERLINE)
1729 force_manual_underline = 1;
1730 /* Don't do the same for manual bold, it could be bad news. */
1732 nfont &= ~(FONT_BOLD|FONT_UNDERLINE);
1734 if (font_needs_hand_underlining && (attr & ATTR_UNDER))
1735 force_manual_underline = 1;
1736 if (attr & ATTR_REVERSE) {
1737 t = nfg; nfg = nbg; nbg = t;
1739 if (bold_mode == BOLD_COLOURS && (attr & ATTR_BOLD))
1741 if (bold_mode == BOLD_COLOURS && (attr & ATTR_BLINK))
1745 SelectObject (hdc, fonts[nfont]);
1746 SetTextColor (hdc, fg);
1747 SetBkColor (hdc, bg);
1748 SetBkMode (hdc, OPAQUE);
1751 line_box.right = x+fnt_width*len;
1752 line_box.bottom = y+font_height;
1753 ExtTextOut (hdc, x, y, ETO_CLIPPED|ETO_OPAQUE, &line_box, text, len, IpDx);
1754 if (bold_mode == BOLD_SHADOW && (attr & ATTR_BOLD)) {
1755 SetBkMode (hdc, TRANSPARENT);
1757 /* GRR: This draws the character outside it's box and can leave
1758 * 'droppings' even with the clip box! I suppose I could loop it
1759 * one character at a time ... yuk.
1761 * Or ... I could do a test print with "W", and use +1 or -1 for this
1762 * shift depending on if the leftmost column is blank...
1764 ExtTextOut (hdc, x-1, y, ETO_CLIPPED, &line_box, text, len, IpDx);
1766 if (force_manual_underline ||
1767 (und_mode == UND_LINE && (attr & ATTR_UNDER))) {
1769 oldpen = SelectObject (hdc, CreatePen(PS_SOLID, 0, fg));
1770 MoveToEx (hdc, x, y+descent, NULL);
1771 LineTo (hdc, x+len*fnt_width, y+descent);
1772 oldpen = SelectObject (hdc, oldpen);
1773 DeleteObject (oldpen);
1775 if (attr & ATTR_PASCURS) {
1778 pts[0].x = pts[1].x = pts[4].x = x;
1779 pts[2].x = pts[3].x = x+fnt_width-1;
1780 pts[0].y = pts[3].y = pts[4].y = y;
1781 pts[1].y = pts[2].y = y+font_height-1;
1782 oldpen = SelectObject (hdc, CreatePen(PS_SOLID, 0, colours[23]));
1783 Polyline (hdc, pts, 5);
1784 oldpen = SelectObject (hdc, oldpen);
1785 DeleteObject (oldpen);
1789 static int check_compose(int first, int second) {
1791 static char * composetbl[] = {
1792 "++#", "AA@", "(([", "//\\", "))]", "(-{", "-)}", "/^|", "!!¡", "C/¢",
1793 "C|¢", "L-£", "L=£", "XO¤", "X0¤", "Y-¥", "Y=¥", "||¦", "SO§", "S!§",
1794 "S0§", "\"\"¨", "CO©", "C0©", "A_ª", "<<«", ",-¬", "--", "RO®",
1795 "-^¯", "0^°", "+-±", "2^²", "3^³", "''´", "/Uµ", "P!¶", ".^·", ",,¸",
1796 "1^¹", "O_º", ">>»", "14¼", "12½", "34¾", "??¿", "`AÀ", "'AÁ", "^AÂ",
1797 "~AÃ", "\"AÄ", "*AÅ", "AEÆ", ",CÇ", "`EÈ", "'EÉ", "^EÊ", "\"EË",
1798 "`IÌ", "'IÍ", "^IÎ", "\"IÏ", "-DÐ", "~NÑ", "`OÒ", "'OÓ", "^OÔ",
1799 "~OÕ", "\"OÖ", "XX×", "/OØ", "`UÙ", "'UÚ", "^UÛ", "\"UÜ", "'YÝ",
1800 "HTÞ", "ssß", "`aà", "'aá", "^aâ", "~aã", "\"aä", "*aå", "aeæ", ",cç",
1801 "`eè", "'eé", "^eê", "\"eë", "`iì", "'ií", "^iî", "\"iï", "-dð", "~nñ",
1802 "`oò", "'oó", "^oô", "~oõ", "\"oö", ":-÷", "o/ø", "`uù", "'uú", "^uû",
1803 "\"uü", "'yý", "htþ", "\"yÿ",
1807 static int recurse = 0;
1810 for(c=composetbl; *c; c++) {
1811 if( (*c)[0] == first && (*c)[1] == second)
1813 return (*c)[2] & 0xFF;
1820 nc = check_compose(second, first);
1822 nc = check_compose(toupper(first), toupper(second));
1824 nc = check_compose(toupper(second), toupper(first));
1832 * Translate a WM_(SYS)?KEY(UP|DOWN) message into a string of ASCII
1833 * codes. Returns number of bytes used or zero to drop the message
1834 * or -1 to forward the message to windows.
1836 static int TranslateKey(UINT message, WPARAM wParam, LPARAM lParam,
1837 unsigned char *output) {
1839 int scan, left_alt = 0, key_down, shift_state;
1841 unsigned char * p = output;
1843 static WORD keys[3];
1844 static int compose_char = 0;
1845 static WPARAM compose_key = 0;
1847 r = GetKeyboardState(keystate);
1848 if (!r) memset(keystate, 0, sizeof(keystate));
1852 { /* Tell us all about key events */
1853 static BYTE oldstate[256];
1854 static int first = 1;
1857 if(first) memcpy(oldstate, keystate, sizeof(oldstate));
1860 if ((HIWORD(lParam)&(KF_UP|KF_REPEAT))==KF_REPEAT) {
1862 } else if ((HIWORD(lParam)&KF_UP) && scan==(HIWORD(lParam) & 0xFF) ) {
1866 if (wParam >= VK_F1 && wParam <= VK_F20 )
1867 debug(("K_F%d", wParam+1-VK_F1));
1870 case VK_SHIFT: debug(("SHIFT")); break;
1871 case VK_CONTROL: debug(("CTRL")); break;
1872 case VK_MENU: debug(("ALT")); break;
1873 default: debug(("VK_%02x", wParam));
1875 if(message == WM_SYSKEYDOWN || message == WM_SYSKEYUP)
1877 debug((", S%02x", scan=(HIWORD(lParam) & 0xFF) ));
1879 ch = MapVirtualKey(wParam, 2);
1880 if (ch>=' ' && ch<='~') debug((", '%c'", ch));
1881 else if (ch) debug((", $%02x", ch));
1883 if (keys[0]) debug((", KB0=%02x", keys[0]));
1884 if (keys[1]) debug((", KB1=%02x", keys[1]));
1885 if (keys[2]) debug((", KB2=%02x", keys[2]));
1887 if ( (keystate[VK_SHIFT]&0x80)!=0) debug((", S"));
1888 if ( (keystate[VK_CONTROL]&0x80)!=0) debug((", C"));
1889 if ( (HIWORD(lParam)&KF_EXTENDED) ) debug((", E"));
1890 if ( (HIWORD(lParam)&KF_UP) ) debug((", U"));
1893 if ((HIWORD(lParam)&(KF_UP|KF_REPEAT))==KF_REPEAT)
1895 else if ( (HIWORD(lParam)&KF_UP) )
1896 oldstate[wParam&0xFF] ^= 0x80;
1898 oldstate[wParam&0xFF] ^= 0x81;
1900 for(ch=0; ch<256; ch++)
1901 if (oldstate[ch] != keystate[ch])
1902 debug((", M%02x=%02x", ch, keystate[ch]));
1904 memcpy(oldstate, keystate, sizeof(oldstate));
1908 /* Note if AltGr was pressed and if it was used as a compose key */
1909 if (cfg.compose_key) {
1910 if (wParam == VK_MENU && (HIWORD(lParam)&KF_EXTENDED))
1912 keystate[VK_RMENU] = keystate[VK_MENU];
1913 if (!compose_state) compose_key = wParam;
1915 if (wParam == VK_APPS && !compose_state)
1916 compose_key = wParam;
1918 if (wParam == compose_key)
1920 if (compose_state == 0 && (HIWORD(lParam)&(KF_UP|KF_REPEAT))==0)
1922 else if (compose_state == 1 && (HIWORD(lParam)&KF_UP))
1927 else if (compose_state==1 && wParam != VK_CONTROL)
1932 /* Nastyness with NUMLock - Shift-NUMLock is left alone though */
1933 if ( (cfg.funky_type == 3 ||
1934 (cfg.funky_type <= 1 && app_keypad_keys && !cfg.no_applic_k))
1935 && wParam==VK_NUMLOCK && !(keystate[VK_SHIFT]&0x80)) {
1937 wParam = VK_EXECUTE;
1939 /* UnToggle NUMLock */
1940 if ((HIWORD(lParam)&(KF_UP|KF_REPEAT))==0)
1941 keystate[VK_NUMLOCK] ^= 1;
1944 /* And write back the 'adjusted' state */
1945 SetKeyboardState (keystate);
1948 /* Disable Auto repeat if required */
1949 if (repeat_off && (HIWORD(lParam)&(KF_UP|KF_REPEAT))==KF_REPEAT)
1952 if ((HIWORD(lParam)&KF_ALTDOWN) && (keystate[VK_RMENU]&0x80) == 0)
1955 key_down = ((HIWORD(lParam)&KF_UP)==0);
1957 /* Make sure Ctrl-ALT is not the same as AltGr for ToAscii */
1958 if (left_alt && (keystate[VK_CONTROL]&0x80))
1959 keystate[VK_MENU] = 0;
1961 scan = (HIWORD(lParam) & (KF_UP | KF_EXTENDED | 0xFF));
1962 shift_state = ((keystate[VK_SHIFT]&0x80)!=0)
1963 + ((keystate[VK_CONTROL]&0x80)!=0)*2;
1966 * Record that we pressed key so the scroll window can be reset, but
1967 * be careful to avoid Shift-UP/Down
1969 if( wParam != VK_SHIFT && wParam != VK_PRIOR && wParam != VK_NEXT ) {
1973 /* Make sure we're not pasting */
1974 if (key_down) term_nopaste();
1976 if (compose_state>1 && left_alt) compose_state = 0;
1978 /* Sanitize the number pad if not using a PC NumPad */
1979 if( left_alt || (app_keypad_keys && !cfg.no_applic_k
1980 && cfg.funky_type != 2)
1981 || cfg.funky_type == 3 || cfg.nethack_keypad || compose_state )
1983 if ((HIWORD(lParam)&KF_EXTENDED) == 0)
1988 case VK_INSERT: nParam = VK_NUMPAD0; break;
1989 case VK_END: nParam = VK_NUMPAD1; break;
1990 case VK_DOWN: nParam = VK_NUMPAD2; break;
1991 case VK_NEXT: nParam = VK_NUMPAD3; break;
1992 case VK_LEFT: nParam = VK_NUMPAD4; break;
1993 case VK_CLEAR: nParam = VK_NUMPAD5; break;
1994 case VK_RIGHT: nParam = VK_NUMPAD6; break;
1995 case VK_HOME: nParam = VK_NUMPAD7; break;
1996 case VK_UP: nParam = VK_NUMPAD8; break;
1997 case VK_PRIOR: nParam = VK_NUMPAD9; break;
1998 case VK_DELETE: nParam = VK_DECIMAL; break;
2002 if (keystate[VK_NUMLOCK]&1) shift_state |= 1;
2008 /* If a key is pressed and AltGr is not active */
2009 if (key_down && (keystate[VK_RMENU]&0x80) == 0 && !compose_state)
2011 /* Okay, prepare for most alts then ...*/
2012 if (left_alt) *p++ = '\033';
2014 /* Lets see if it's a pattern we know all about ... */
2015 if (wParam == VK_PRIOR && shift_state == 1) {
2016 SendMessage (hwnd, WM_VSCROLL, SB_PAGEUP, 0);
2019 if (wParam == VK_NEXT && shift_state == 1) {
2020 SendMessage (hwnd, WM_VSCROLL, SB_PAGEDOWN, 0);
2023 if (wParam == VK_INSERT && shift_state == 1) {
2024 term_mouse (MB_PASTE, MA_CLICK, 0, 0);
2025 term_mouse (MB_PASTE, MA_RELEASE, 0, 0);
2028 if (left_alt && wParam == VK_F4 && cfg.alt_f4) {
2031 if (left_alt && wParam == VK_SPACE && cfg.alt_space) {
2032 PostMessage(hwnd, WM_CHAR, ' ', 0);
2033 SendMessage (hwnd, WM_SYSCOMMAND, SC_KEYMENU, 0);
2036 /* Control-Numlock for app-keypad mode switch */
2037 if (wParam == VK_PAUSE && shift_state == 2) {
2038 app_keypad_keys ^= 1;
2042 /* Nethack keypad */
2043 if (cfg.nethack_keypad && !left_alt) {
2045 case VK_NUMPAD1: *p++ = shift_state ? 'B': 'b'; return p-output;
2046 case VK_NUMPAD2: *p++ = shift_state ? 'J': 'j'; return p-output;
2047 case VK_NUMPAD3: *p++ = shift_state ? 'N': 'n'; return p-output;
2048 case VK_NUMPAD4: *p++ = shift_state ? 'H': 'h'; return p-output;
2049 case VK_NUMPAD5: *p++ = shift_state ? '.': '.'; return p-output;
2050 case VK_NUMPAD6: *p++ = shift_state ? 'L': 'l'; return p-output;
2051 case VK_NUMPAD7: *p++ = shift_state ? 'Y': 'y'; return p-output;
2052 case VK_NUMPAD8: *p++ = shift_state ? 'K': 'k'; return p-output;
2053 case VK_NUMPAD9: *p++ = shift_state ? 'U': 'u'; return p-output;
2057 /* Application Keypad */
2061 if ( cfg.funky_type == 3 ||
2062 ( cfg.funky_type <= 1 &&
2063 app_keypad_keys && !cfg.no_applic_k)) switch(wParam) {
2064 case VK_EXECUTE: xkey = 'P'; break;
2065 case VK_DIVIDE: xkey = 'Q'; break;
2066 case VK_MULTIPLY:xkey = 'R'; break;
2067 case VK_SUBTRACT:xkey = 'S'; break;
2069 if(app_keypad_keys && !cfg.no_applic_k) switch(wParam) {
2070 case VK_NUMPAD0: xkey = 'p'; break;
2071 case VK_NUMPAD1: xkey = 'q'; break;
2072 case VK_NUMPAD2: xkey = 'r'; break;
2073 case VK_NUMPAD3: xkey = 's'; break;
2074 case VK_NUMPAD4: xkey = 't'; break;
2075 case VK_NUMPAD5: xkey = 'u'; break;
2076 case VK_NUMPAD6: xkey = 'v'; break;
2077 case VK_NUMPAD7: xkey = 'w'; break;
2078 case VK_NUMPAD8: xkey = 'x'; break;
2079 case VK_NUMPAD9: xkey = 'y'; break;
2081 case VK_DECIMAL: xkey = 'n'; break;
2082 case VK_ADD: if(cfg.funky_type==2) {
2083 if(shift_state) xkey = 'l';
2085 } else if(shift_state) xkey = 'm';
2089 case VK_DIVIDE: if(cfg.funky_type==2) xkey = 'o'; break;
2090 case VK_MULTIPLY:if(cfg.funky_type==2) xkey = 'j'; break;
2091 case VK_SUBTRACT:if(cfg.funky_type==2) xkey = 'm'; break;
2094 if (HIWORD(lParam)&KF_EXTENDED)
2102 if (xkey>='P' && xkey<='S')
2103 p += sprintf((char *)p, "\x1B%c", xkey);
2105 p += sprintf((char *)p, "\x1B?%c", xkey);
2108 p += sprintf((char *)p, "\x1BO%c", xkey);
2113 if (wParam == VK_BACK && shift_state == 0 ) /* Backspace */
2115 *p++ = (cfg.bksp_is_delete ? 0x7F : 0x08);
2118 if (wParam == VK_TAB && shift_state == 1 ) /* Shift tab */
2120 *p++ = 0x1B; *p++ = '['; *p++ = 'Z'; return p - output;
2122 if (wParam == VK_SPACE && shift_state == 2 ) /* Ctrl-Space */
2124 *p++ = 0; return p - output;
2126 if (wParam == VK_SPACE && shift_state == 3 ) /* Ctrl-Shift-Space */
2128 *p++ = 160; return p - output;
2130 if (wParam == VK_CANCEL && shift_state == 2 ) /* Ctrl-Break */
2132 *p++ = 3; return p - output;
2134 /* Control-2 to Control-8 are special */
2135 if (shift_state == 2 && wParam >= '2' && wParam <= '8')
2137 *p++ = "\000\033\034\035\036\037\177"[wParam-'2'];
2140 if (shift_state == 2 && wParam == 0xBD) {
2144 if (shift_state == 2 && wParam == 0xDF) {
2148 if (shift_state == 0 && wParam == VK_RETURN && cr_lf_return) {
2149 *p++ = '\r'; *p++ = '\n';
2154 * Next, all the keys that do tilde codes. (ESC '[' nn '~',
2155 * for integer decimal nn.)
2157 * We also deal with the weird ones here. Linux VCs replace F1
2158 * to F5 by ESC [ [ A to ESC [ [ E. rxvt doesn't do _that_, but
2159 * does replace Home and End (1~ and 4~) by ESC [ H and ESC O w
2164 case VK_F1: code = (keystate[VK_SHIFT] & 0x80 ? 23 : 11); break;
2165 case VK_F2: code = (keystate[VK_SHIFT] & 0x80 ? 24 : 12); break;
2166 case VK_F3: code = (keystate[VK_SHIFT] & 0x80 ? 25 : 13); break;
2167 case VK_F4: code = (keystate[VK_SHIFT] & 0x80 ? 26 : 14); break;
2168 case VK_F5: code = (keystate[VK_SHIFT] & 0x80 ? 28 : 15); break;
2169 case VK_F6: code = (keystate[VK_SHIFT] & 0x80 ? 29 : 17); break;
2170 case VK_F7: code = (keystate[VK_SHIFT] & 0x80 ? 31 : 18); break;
2171 case VK_F8: code = (keystate[VK_SHIFT] & 0x80 ? 32 : 19); break;
2172 case VK_F9: code = (keystate[VK_SHIFT] & 0x80 ? 33 : 20); break;
2173 case VK_F10: code = (keystate[VK_SHIFT] & 0x80 ? 34 : 21); break;
2174 case VK_F11: code = 23; break;
2175 case VK_F12: code = 24; break;
2176 case VK_F13: code = 25; break;
2177 case VK_F14: code = 26; break;
2178 case VK_F15: code = 28; break;
2179 case VK_F16: code = 29; break;
2180 case VK_F17: code = 31; break;
2181 case VK_F18: code = 32; break;
2182 case VK_F19: code = 33; break;
2183 case VK_F20: code = 34; break;
2184 case VK_HOME: code = 1; break;
2185 case VK_INSERT: code = 2; break;
2186 case VK_DELETE: code = 3; break;
2187 case VK_END: code = 4; break;
2188 case VK_PRIOR: code = 5; break;
2189 case VK_NEXT: code = 6; break;
2191 /* Reorder edit keys to physical order */
2192 if (cfg.funky_type == 3 && code <= 6 ) code = "\0\2\1\4\5\3\6"[code];
2194 if (cfg.funky_type == 1 && code >= 11 && code <= 15) {
2195 p += sprintf((char *)p, "\x1B[[%c", code + 'A' - 11);
2198 if (cfg.funky_type == 2 && code >= 11 && code <= 14) {
2200 p += sprintf((char *)p, "\x1B%c", code + 'P' - 11);
2202 p += sprintf((char *)p, "\x1BO%c", code + 'P' - 11);
2205 if (cfg.rxvt_homeend && (code == 1 || code == 4)) {
2206 p += sprintf((char *)p, code == 1 ? "\x1B[H" : "\x1BOw");
2210 p += sprintf((char *)p, "\x1B[%d~", code);
2215 * Now the remaining keys (arrows and Keypad 5. Keypad 5 for
2216 * some reason seems to send VK_CLEAR to Windows...).
2221 case VK_UP: xkey = 'A'; break;
2222 case VK_DOWN: xkey = 'B'; break;
2223 case VK_RIGHT: xkey = 'C'; break;
2224 case VK_LEFT: xkey = 'D'; break;
2225 case VK_CLEAR: xkey = 'G'; break;
2230 p += sprintf((char *)p, "\x1B%c", xkey);
2231 else if (app_cursor_keys && !cfg.no_applic_c)
2232 p += sprintf((char *)p, "\x1BO%c", xkey);
2234 p += sprintf((char *)p, "\x1B[%c", xkey);
2240 * Finally, deal with Return ourselves. (Win95 seems to
2241 * foul it up when Alt is pressed, for some reason.)
2243 if (wParam == VK_RETURN) /* Return */
2250 /* Okay we've done everything interesting; let windows deal with
2251 * the boring stuff */
2253 BOOL capsOn=keystate[VK_CAPITAL] !=0;
2255 /* helg: clear CAPS LOCK state if caps lock switches to cyrillic */
2256 if(cfg.xlat_capslockcyr)
2257 keystate[VK_CAPITAL] = 0;
2259 r = ToAscii (wParam, scan, keystate, keys, 0);
2265 unsigned char ch = (unsigned char)keys[i];
2267 if (compose_state==2 && (ch&0x80) == 0 && ch>' ') {
2272 if (compose_state==3 && (ch&0x80) == 0 && ch>' ') {
2276 if ((nc=check_compose(compose_char,ch)) == -1)
2278 MessageBeep(MB_ICONHAND);
2281 *p++ = xlat_kbd2tty((unsigned char)nc);
2287 if( left_alt && key_down ) *p++ = '\033';
2293 ch = xlat_latkbd2win(ch);
2294 *p++ = xlat_kbd2tty(ch);
2298 /* This is so the ALT-Numpad and dead keys work correctly. */
2305 /* ALT alone may or may not want to bring up the System menu */
2306 if (wParam == VK_MENU) {
2308 static int alt_state = 0;
2309 if (message == WM_SYSKEYDOWN)
2311 else if (message == WM_SYSKEYUP && alt_state)
2312 PostMessage(hwnd, WM_CHAR, ' ', 0);
2313 if (message == WM_SYSKEYUP)
2322 void set_title (char *title) {
2323 sfree (window_name);
2324 window_name = smalloc(1+strlen(title));
2325 strcpy (window_name, title);
2326 if (cfg.win_name_always || !IsIconic(hwnd))
2327 SetWindowText (hwnd, title);
2330 void set_icon (char *title) {
2332 icon_name = smalloc(1+strlen(title));
2333 strcpy (icon_name, title);
2334 if (!cfg.win_name_always && IsIconic(hwnd))
2335 SetWindowText (hwnd, title);
2338 void set_sbar (int total, int start, int page) {
2341 if (!cfg.scrollbar) return;
2343 si.cbSize = sizeof(si);
2344 si.fMask = SIF_ALL | SIF_DISABLENOSCROLL;
2346 si.nMax = total - 1;
2350 SetScrollInfo (hwnd, SB_VERT, &si, TRUE);
2353 Context get_ctx(void) {
2358 SelectPalette (hdc, pal, FALSE);
2364 void free_ctx (Context ctx) {
2365 SelectPalette (ctx, GetStockObject (DEFAULT_PALETTE), FALSE);
2366 ReleaseDC (hwnd, ctx);
2369 static void real_palette_set (int n, int r, int g, int b) {
2371 logpal->palPalEntry[n].peRed = r;
2372 logpal->palPalEntry[n].peGreen = g;
2373 logpal->palPalEntry[n].peBlue = b;
2374 logpal->palPalEntry[n].peFlags = PC_NOCOLLAPSE;
2375 colours[n] = PALETTERGB(r, g, b);
2376 SetPaletteEntries (pal, 0, NCOLOURS, logpal->palPalEntry);
2378 colours[n] = RGB(r, g, b);
2381 void palette_set (int n, int r, int g, int b) {
2382 static const int first[21] = {
2383 0, 2, 4, 6, 8, 10, 12, 14,
2384 1, 3, 5, 7, 9, 11, 13, 15,
2387 real_palette_set (first[n], r, g, b);
2389 real_palette_set (first[n]+1, r, g, b);
2391 HDC hdc = get_ctx();
2392 UnrealizeObject (pal);
2393 RealizePalette (hdc);
2398 void palette_reset (void) {
2401 for (i = 0; i < NCOLOURS; i++) {
2403 logpal->palPalEntry[i].peRed = defpal[i].rgbtRed;
2404 logpal->palPalEntry[i].peGreen = defpal[i].rgbtGreen;
2405 logpal->palPalEntry[i].peBlue = defpal[i].rgbtBlue;
2406 logpal->palPalEntry[i].peFlags = 0;
2407 colours[i] = PALETTERGB(defpal[i].rgbtRed,
2408 defpal[i].rgbtGreen,
2409 defpal[i].rgbtBlue);
2411 colours[i] = RGB(defpal[i].rgbtRed,
2412 defpal[i].rgbtGreen,
2413 defpal[i].rgbtBlue);
2418 SetPaletteEntries (pal, 0, NCOLOURS, logpal->palPalEntry);
2420 RealizePalette (hdc);
2425 void write_clip (void *data, int len, int must_deselect) {
2429 clipdata = GlobalAlloc (GMEM_DDESHARE | GMEM_MOVEABLE, len + 1);
2432 lock = GlobalLock (clipdata);
2435 memcpy (lock, data, len);
2436 ((unsigned char *) lock) [len] = 0;
2437 GlobalUnlock (clipdata);
2440 SendMessage (hwnd, WM_IGNORE_CLIP, TRUE, 0);
2442 if (OpenClipboard (hwnd)) {
2444 SetClipboardData (CF_TEXT, clipdata);
2447 GlobalFree (clipdata);
2450 SendMessage (hwnd, WM_IGNORE_CLIP, FALSE, 0);
2453 void get_clip (void **p, int *len) {
2454 static HGLOBAL clipdata = NULL;
2458 GlobalUnlock (clipdata);
2462 if (OpenClipboard (NULL)) {
2463 clipdata = GetClipboardData (CF_TEXT);
2466 *p = GlobalLock (clipdata);
2480 * Move `lines' lines from position `from' to position `to' in the
2483 void optimised_move (int to, int from, int lines) {
2487 min = (to < from ? to : from);
2488 max = to + from - min;
2490 r.left = 0; r.right = cols * font_width;
2491 r.top = min * font_height; r.bottom = (max+lines) * font_height;
2492 ScrollWindow (hwnd, 0, (to - from) * font_height, &r, &r);
2496 * Print a message box and perform a fatal exit.
2498 void fatalbox(char *fmt, ...) {
2503 vsprintf(stuff, fmt, ap);
2505 MessageBox(hwnd, stuff, "PuTTY Fatal Error", MB_ICONERROR | MB_OK);
2512 void beep(int errorbeep) {
2513 static long last_beep = 0;
2514 long now, beep_diff;
2516 now = GetTickCount();
2517 beep_diff = now-last_beep;
2519 /* Make sure we only respond to one beep per packet or so */
2520 if (beep_diff>=0 && beep_diff<50)
2524 MessageBeep(MB_ICONHAND);
2528 last_beep = GetTickCount();