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);
1159 if (!do_reconfig(hwnd))
1161 just_reconfigged = TRUE;
1166 DeleteObject(fonts[i]);
1168 bold_mode = cfg.bold_colour ? BOLD_COLOURS : BOLD_FONT;
1169 und_mode = UND_FONT;
1172 /* Telnet will change local echo -> remote if the remote asks */
1173 if (cfg.protocol != PROT_TELNET)
1174 ldisc = (cfg.ldisc_term ? &ldisc_term : &ldisc_simple);
1182 /* Enable or disable the scroll bar, etc */
1184 LONG nflg, flag = GetWindowLong(hwnd, GWL_STYLE);
1185 LONG nexflag, exflag = GetWindowLong(hwnd, GWL_EXSTYLE);
1188 if (cfg.alwaysontop) {
1189 nexflag = WS_EX_TOPMOST;
1190 SetWindowPos(hwnd, HWND_TOPMOST, 0, 0, 0, 0, SWP_NOSIZE);
1193 SetWindowPos(hwnd, HWND_NOTOPMOST, 0, 0, 0, 0, SWP_NOSIZE);
1197 if (cfg.scrollbar) nflg |= WS_VSCROLL;
1198 else nflg &= ~WS_VSCROLL;
1200 nflg &= ~(WS_THICKFRAME|WS_MAXIMIZEBOX);
1202 nflg |= (WS_THICKFRAME|WS_MAXIMIZEBOX);
1204 if (nflg != flag || nexflag != exflag)
1209 SetWindowLong(hwnd, GWL_STYLE, nflg);
1210 if (nexflag != exflag)
1211 SetWindowLong(hwnd, GWL_EXSTYLE, nexflag);
1213 SendMessage (hwnd, WM_IGNORE_SIZE, 0, 0);
1214 SetWindowPos(hwnd, NULL, 0,0,0,0,
1215 SWP_NOACTIVATE|SWP_NOCOPYBITS|
1216 SWP_NOMOVE|SWP_NOSIZE|SWP_NOZORDER|
1219 GetWindowRect (hwnd, &wr);
1220 GetClientRect (hwnd, &cr);
1221 extra_width = wr.right - wr.left - cr.right + cr.left;
1222 extra_height = wr.bottom - wr.top - cr.bottom + cr.top;
1226 term_size(cfg.height, cfg.width, cfg.savelines);
1227 InvalidateRect(hwnd, NULL, TRUE);
1228 SetWindowPos (hwnd, NULL, 0, 0,
1229 extra_width + font_width * cfg.width,
1230 extra_height + font_height * cfg.height,
1231 SWP_NOACTIVATE | SWP_NOCOPYBITS |
1232 SWP_NOMOVE | SWP_NOZORDER);
1233 if (IsIconic(hwnd)) {
1234 SetWindowText (hwnd,
1235 cfg.win_name_always ? window_name : icon_name);
1244 case IDM_TEL_AYT: back->special (TS_AYT); break;
1245 case IDM_TEL_BRK: back->special (TS_BRK); break;
1246 case IDM_TEL_SYNCH: back->special (TS_SYNCH); break;
1247 case IDM_TEL_EC: back->special (TS_EC); break;
1248 case IDM_TEL_EL: back->special (TS_EL); break;
1249 case IDM_TEL_GA: back->special (TS_GA); break;
1250 case IDM_TEL_NOP: back->special (TS_NOP); break;
1251 case IDM_TEL_ABORT: back->special (TS_ABORT); break;
1252 case IDM_TEL_AO: back->special (TS_AO); break;
1253 case IDM_TEL_IP: back->special (TS_IP); break;
1254 case IDM_TEL_SUSP: back->special (TS_SUSP); break;
1255 case IDM_TEL_EOR: back->special (TS_EOR); break;
1256 case IDM_TEL_EOF: back->special (TS_EOF); break;
1261 if (wParam >= IDM_SAVED_MIN && wParam <= IDM_SAVED_MAX) {
1262 SendMessage(hwnd, WM_SYSCOMMAND, IDM_SAVEDSESS, wParam);
1267 #define X_POS(l) ((int)(short)LOWORD(l))
1268 #define Y_POS(l) ((int)(short)HIWORD(l))
1270 #define TO_CHR_X(x) (((x)<0 ? (x)-font_width+1 : (x)) / font_width)
1271 #define TO_CHR_Y(y) (((y)<0 ? (y)-font_height+1: (y)) / font_height)
1273 case WM_LBUTTONDOWN:
1274 click (MB_SELECT, TO_CHR_X(X_POS(lParam)),
1275 TO_CHR_Y(Y_POS(lParam)));
1279 term_mouse (MB_SELECT, MA_RELEASE, TO_CHR_X(X_POS(lParam)),
1280 TO_CHR_Y(Y_POS(lParam)));
1283 case WM_MBUTTONDOWN:
1285 click (cfg.mouse_is_xterm ? MB_PASTE : MB_EXTEND,
1286 TO_CHR_X(X_POS(lParam)),
1287 TO_CHR_Y(Y_POS(lParam)));
1290 term_mouse (cfg.mouse_is_xterm ? MB_PASTE : MB_EXTEND,
1291 MA_RELEASE, TO_CHR_X(X_POS(lParam)),
1292 TO_CHR_Y(Y_POS(lParam)));
1295 case WM_RBUTTONDOWN:
1297 click (cfg.mouse_is_xterm ? MB_EXTEND : MB_PASTE,
1298 TO_CHR_X(X_POS(lParam)),
1299 TO_CHR_Y(Y_POS(lParam)));
1302 term_mouse (cfg.mouse_is_xterm ? MB_EXTEND : MB_PASTE,
1303 MA_RELEASE, TO_CHR_X(X_POS(lParam)),
1304 TO_CHR_Y(Y_POS(lParam)));
1309 * Add the mouse position and message time to the random
1312 noise_ultralight(lParam);
1314 if (wParam & (MK_LBUTTON | MK_MBUTTON | MK_RBUTTON)) {
1316 if (wParam & MK_LBUTTON)
1318 else if (wParam & MK_MBUTTON)
1319 b = cfg.mouse_is_xterm ? MB_PASTE : MB_EXTEND;
1321 b = cfg.mouse_is_xterm ? MB_EXTEND : MB_PASTE;
1322 term_mouse (b, MA_DRAG, TO_CHR_X(X_POS(lParam)),
1323 TO_CHR_Y(Y_POS(lParam)));
1326 case WM_IGNORE_CLIP:
1327 ignore_clip = wParam; /* don't panic on DESTROYCLIPBOARD */
1329 case WM_DESTROYCLIPBOARD:
1332 ignore_clip = FALSE;
1338 hdc = BeginPaint (hwnd, &p);
1340 SelectPalette (hdc, pal, TRUE);
1341 RealizePalette (hdc);
1343 term_paint (hdc, p.rcPaint.left, p.rcPaint.top,
1344 p.rcPaint.right, p.rcPaint.bottom);
1345 SelectObject (hdc, GetStockObject(SYSTEM_FONT));
1346 SelectObject (hdc, GetStockObject(WHITE_PEN));
1347 EndPaint (hwnd, &p);
1352 /* Notice we can get multiple netevents, FD_READ, FD_WRITE etc
1353 * but the only one that's likely to try to overload us is FD_READ.
1354 * This means buffering just one is fine.
1356 if (pending_netevent)
1357 enact_pending_netevent();
1359 pending_netevent = TRUE;
1360 pend_netevent_wParam=wParam;
1361 pend_netevent_lParam=lParam;
1362 time(&last_movement);
1366 CreateCaret(hwnd, caretbm, 0, 0);
1378 case WM_IGNORE_SIZE:
1379 ignore_size = TRUE; /* don't panic on next WM_SIZE msg */
1381 case WM_ENTERSIZEMOVE:
1385 case WM_EXITSIZEMOVE:
1392 int width, height, w, h, ew, eh;
1393 LPRECT r = (LPRECT)lParam;
1395 width = r->right - r->left - extra_width;
1396 height = r->bottom - r->top - extra_height;
1397 w = (width + font_width/2) / font_width; if (w < 1) w = 1;
1398 h = (height + font_height/2) / font_height; if (h < 1) h = 1;
1399 UpdateSizeTip(hwnd, w, h);
1400 ew = width - w * font_width;
1401 eh = height - h * font_height;
1403 if (wParam == WMSZ_LEFT ||
1404 wParam == WMSZ_BOTTOMLEFT ||
1405 wParam == WMSZ_TOPLEFT)
1411 if (wParam == WMSZ_TOP ||
1412 wParam == WMSZ_TOPRIGHT ||
1413 wParam == WMSZ_TOPLEFT)
1423 /* break; (never reached) */
1425 if (wParam == SIZE_MINIMIZED) {
1426 SetWindowText (hwnd,
1427 cfg.win_name_always ? window_name : icon_name);
1430 if (wParam == SIZE_RESTORED || wParam == SIZE_MAXIMIZED)
1431 SetWindowText (hwnd, window_name);
1433 int width, height, w, h;
1434 #if 0 /* we have fixed this using WM_SIZING now */
1438 width = LOWORD(lParam);
1439 height = HIWORD(lParam);
1440 w = width / font_width; if (w < 1) w = 1;
1441 h = height / font_height; if (h < 1) h = 1;
1442 #if 0 /* we have fixed this using WM_SIZING now */
1443 ew = width - w * font_width;
1444 eh = height - h * font_height;
1445 if (ew != 0 || eh != 0) {
1447 GetWindowRect (hwnd, &r);
1448 SendMessage (hwnd, WM_IGNORE_SIZE, 0, 0);
1449 SetWindowPos (hwnd, NULL, 0, 0,
1450 r.right - r.left - ew, r.bottom - r.top - eh,
1451 SWP_NOACTIVATE | SWP_NOMOVE | SWP_NOZORDER);
1454 if (w != cols || h != rows || just_reconfigged) {
1456 term_size (h, w, cfg.savelines);
1458 * Don't call back->size in mid-resize. (To prevent
1459 * massive numbers of resize events getting sent
1460 * down the connection during an NT opaque drag.)
1464 just_reconfigged = FALSE;
1467 ignore_size = FALSE;
1470 switch (LOWORD(wParam)) {
1471 case SB_BOTTOM: term_scroll(-1, 0); break;
1472 case SB_TOP: term_scroll(+1, 0); break;
1473 case SB_LINEDOWN: term_scroll (0, +1); break;
1474 case SB_LINEUP: term_scroll (0, -1); break;
1475 case SB_PAGEDOWN: term_scroll (0, +rows/2); break;
1476 case SB_PAGEUP: term_scroll (0, -rows/2); break;
1477 case SB_THUMBPOSITION: case SB_THUMBTRACK:
1478 term_scroll (1, HIWORD(wParam)); break;
1481 case WM_PALETTECHANGED:
1482 if ((HWND) wParam != hwnd && pal != NULL) {
1483 HDC hdc = get_ctx();
1485 if (RealizePalette (hdc) > 0)
1491 case WM_QUERYNEWPALETTE:
1493 HDC hdc = get_ctx();
1495 if (RealizePalette (hdc) > 0)
1507 * Add the scan code and keypress timing to the random
1510 noise_ultralight(lParam);
1513 * We don't do TranslateMessage since it disassociates the
1514 * resulting CHAR message from the KEYDOWN that sparked it,
1515 * which we occasionally don't want. Instead, we process
1516 * KEYDOWN, and call the Win32 translator functions so that
1517 * we get the translations under _our_ control.
1520 unsigned char buf[20];
1523 if (wParam==VK_PROCESSKEY) {
1526 m.message = WM_KEYDOWN;
1528 m.lParam = lParam & 0xdfff;
1529 TranslateMessage(&m);
1531 len = TranslateKey (message, wParam, lParam, buf);
1533 return DefWindowProc (hwnd, message, wParam, lParam);
1534 ldisc->send (buf, len);
1540 unsigned char buf[2];
1543 buf[0] = wParam >> 8;
1544 ldisc->send (buf, 2);
1549 * Nevertheless, we are prepared to deal with WM_CHAR
1550 * messages, should they crop up. So if someone wants to
1551 * post the things to us as part of a macro manoeuvre,
1552 * we're ready to cope.
1555 char c = xlat_kbd2tty((unsigned char)wParam);
1556 ldisc->send (&c, 1);
1561 return DefWindowProc (hwnd, message, wParam, lParam);
1565 * Move the system caret. (We maintain one, even though it's
1566 * invisible, for the benefit of blind people: apparently some
1567 * helper software tracks the system caret, so we should arrange to
1570 void sys_cursor(int x, int y) {
1571 SetCaretPos(x * font_width, y * font_height);
1575 * Draw a line of text in the window, at given character
1576 * coordinates, in given attributes.
1578 * We are allowed to fiddle with the contents of `text'.
1580 void do_text (Context ctx, int x, int y, char *text, int len,
1581 unsigned long attr, int lattr) {
1583 int nfg, nbg, nfont;
1586 int force_manual_underline = 0;
1587 int fnt_width = font_width*(1+(lattr!=LATTR_NORM));
1588 static int *IpDx = 0, IpDxLEN = 0;;
1590 if (len>IpDxLEN || IpDx[0] != fnt_width) {
1594 IpDx = smalloc((len+16)*sizeof(int));
1597 for(i=0; i<IpDxLEN; i++)
1598 IpDx[i] = fnt_width;
1604 if (attr & ATTR_ACTCURS) {
1605 attr &= (bold_mode == BOLD_COLOURS ? 0x300200 : 0x300300);
1606 attr ^= ATTR_CUR_XOR;
1610 if (cfg.vtmode == VT_OEMONLY)
1614 * Map high-half characters in order to approximate ISO using
1615 * OEM character set. No characters are missing if the OEM codepage
1618 if (nfont & FONT_OEM) {
1620 for (i=0; i<len; i++)
1621 if (text[i] >= '\xA0' && text[i] <= '\xFF') {
1623 /* This is CP850 ... perfect translation */
1624 static const char oemhighhalf[] =
1625 "\x20\xAD\xBD\x9C\xCF\xBE\xDD\xF5" /* A0-A7 */
1626 "\xF9\xB8\xA6\xAE\xAA\xF0\xA9\xEE" /* A8-AF */
1627 "\xF8\xF1\xFD\xFC\xEF\xE6\xF4\xFA" /* B0-B7 */
1628 "\xF7\xFB\xA7\xAF\xAC\xAB\xF3\xA8" /* B8-BF */
1629 "\xB7\xB5\xB6\xC7\x8E\x8F\x92\x80" /* C0-C7 */
1630 "\xD4\x90\xD2\xD3\xDE\xD6\xD7\xD8" /* C8-CF */
1631 "\xD1\xA5\xE3\xE0\xE2\xE5\x99\x9E" /* D0-D7 */
1632 "\x9D\xEB\xE9\xEA\x9A\xED\xE8\xE1" /* D8-DF */
1633 "\x85\xA0\x83\xC6\x84\x86\x91\x87" /* E0-E7 */
1634 "\x8A\x82\x88\x89\x8D\xA1\x8C\x8B" /* E8-EF */
1635 "\xD0\xA4\x95\xA2\x93\xE4\x94\xF6" /* F0-F7 */
1636 "\x9B\x97\xA3\x96\x81\xEC\xE7\x98" /* F8-FF */
1639 /* This is CP437 ... junk translation */
1640 static const unsigned char oemhighhalf[] = {
1641 0xff, 0xad, 0x9b, 0x9c, 0x6f, 0x9d, 0x7c, 0x15,
1642 0x22, 0x43, 0xa6, 0xae, 0xaa, 0x2d, 0x52, 0xc4,
1643 0xf8, 0xf1, 0xfd, 0x33, 0x27, 0xe6, 0x14, 0xfa,
1644 0x2c, 0x31, 0xa7, 0xaf, 0xac, 0xab, 0x2f, 0xa8,
1645 0x41, 0x41, 0x41, 0x41, 0x8e, 0x8f, 0x92, 0x80,
1646 0x45, 0x90, 0x45, 0x45, 0x49, 0x49, 0x49, 0x49,
1647 0x44, 0xa5, 0x4f, 0x4f, 0x4f, 0x4f, 0x99, 0x78,
1648 0xed, 0x55, 0x55, 0x55, 0x9a, 0x59, 0x50, 0xe1,
1649 0x85, 0xa0, 0x83, 0x61, 0x84, 0x86, 0x91, 0x87,
1650 0x8a, 0x82, 0x88, 0x89, 0x8d, 0xa1, 0x8c, 0x8b,
1651 0x0b, 0xa4, 0x95, 0xa2, 0x93, 0x6f, 0x94, 0xf6,
1652 0xed, 0x97, 0xa3, 0x96, 0x81, 0x79, 0x70, 0x98
1655 text[i] = oemhighhalf[(unsigned char)text[i] - 0xA0];
1659 if (attr & ATTR_LINEDRW) {
1662 static const char poorman[] =
1663 "*#****\xB0\xB1**+++++-----++++|****\xA3\xB7";
1666 static const char oemmap_437[] =
1667 "\x04\xB1****\xF8\xF1**\xD9\xBF\xDA\xC0\xC5"
1668 "\xC4\xC4\xC4\xC4\xC4\xC3\xB4\xC1\xC2\xB3\xF3\xF2\xE3*\x9C\xFA";
1671 static const char oemmap_850[] =
1672 "\x04\xB1****\xF8\xF1**\xD9\xBF\xDA\xC0\xC5"
1673 "\xC4\xC4\xC4\xC4\xC4\xC3\xB4\xC1\xC2\xB3****\x9C\xFA";
1675 /* Poor windows font ... eg: windows courier */
1676 static const char oemmap[] =
1677 "*\xB1****\xF8\xF1**\xD9\xBF\xDA\xC0\xC5"
1678 "\xC4\xC4\xC4\xC4\xC4\xC3\xB4\xC1\xC2\xB3****\x9C\xFA";
1681 * Line drawing mapping: map ` thru ~ (0x60 thru 0x7E) to
1682 * VT100 line drawing chars; everything else stays normal.
1684 * Actually '_' maps to space too, but that's done before.
1686 switch (cfg.vtmode) {
1688 for (i=0; i<len; i++)
1689 if (text[i] >= '\x60' && text[i] <= '\x7E')
1690 text[i] += '\x01' - '\x60';
1693 /* Make sure we actually have an OEM font */
1694 if (fonts[nfont|FONT_OEM]) {
1697 for (i=0; i<len; i++)
1698 if (text[i] >= '\x60' && text[i] <= '\x7E')
1699 text[i] = oemmap[(unsigned char)text[i] - 0x60];
1703 for (i=0; i<len; i++)
1704 if (text[i] >= '\x60' && text[i] <= '\x7E')
1705 text[i] = poorman[(unsigned char)text[i] - 0x60];
1710 nfg = 2 * ((attr & ATTR_FGMASK) >> ATTR_FGSHIFT);
1711 nbg = 2 * ((attr & ATTR_BGMASK) >> ATTR_BGSHIFT);
1712 if (bold_mode == BOLD_FONT && (attr & ATTR_BOLD))
1714 if (und_mode == UND_FONT && (attr & ATTR_UNDER))
1715 nfont |= FONT_UNDERLINE;
1718 if (nfont&FONT_UNDERLINE)
1719 force_manual_underline = 1;
1720 /* Don't do the same for manual bold, it could be bad news. */
1722 nfont &= ~(FONT_BOLD|FONT_UNDERLINE);
1724 if (font_needs_hand_underlining && (attr & ATTR_UNDER))
1725 force_manual_underline = 1;
1726 if (attr & ATTR_REVERSE) {
1727 t = nfg; nfg = nbg; nbg = t;
1729 if (bold_mode == BOLD_COLOURS && (attr & ATTR_BOLD))
1731 if (bold_mode == BOLD_COLOURS && (attr & ATTR_BLINK))
1735 SelectObject (hdc, fonts[nfont]);
1736 SetTextColor (hdc, fg);
1737 SetBkColor (hdc, bg);
1738 SetBkMode (hdc, OPAQUE);
1741 line_box.right = x+fnt_width*len;
1742 line_box.bottom = y+font_height;
1743 ExtTextOut (hdc, x, y, ETO_CLIPPED|ETO_OPAQUE, &line_box, text, len, IpDx);
1744 if (bold_mode == BOLD_SHADOW && (attr & ATTR_BOLD)) {
1745 SetBkMode (hdc, TRANSPARENT);
1747 /* GRR: This draws the character outside it's box and can leave
1748 * 'droppings' even with the clip box! I suppose I could loop it
1749 * one character at a time ... yuk.
1751 * Or ... I could do a test print with "W", and use +1 or -1 for this
1752 * shift depending on if the leftmost column is blank...
1754 ExtTextOut (hdc, x-1, y, ETO_CLIPPED, &line_box, text, len, IpDx);
1756 if (force_manual_underline ||
1757 (und_mode == UND_LINE && (attr & ATTR_UNDER))) {
1759 oldpen = SelectObject (hdc, CreatePen(PS_SOLID, 0, fg));
1760 MoveToEx (hdc, x, y+descent, NULL);
1761 LineTo (hdc, x+len*fnt_width, y+descent);
1762 oldpen = SelectObject (hdc, oldpen);
1763 DeleteObject (oldpen);
1765 if (attr & ATTR_PASCURS) {
1768 pts[0].x = pts[1].x = pts[4].x = x;
1769 pts[2].x = pts[3].x = x+fnt_width-1;
1770 pts[0].y = pts[3].y = pts[4].y = y;
1771 pts[1].y = pts[2].y = y+font_height-1;
1772 oldpen = SelectObject (hdc, CreatePen(PS_SOLID, 0, colours[23]));
1773 Polyline (hdc, pts, 5);
1774 oldpen = SelectObject (hdc, oldpen);
1775 DeleteObject (oldpen);
1779 static int check_compose(int first, int second) {
1781 static char * composetbl[] = {
1782 "++#", "AA@", "(([", "//\\", "))]", "(-{", "-)}", "/^|", "!!¡", "C/¢",
1783 "C|¢", "L-£", "L=£", "XO¤", "X0¤", "Y-¥", "Y=¥", "||¦", "SO§", "S!§",
1784 "S0§", "\"\"¨", "CO©", "C0©", "A_ª", "<<«", ",-¬", "--", "RO®",
1785 "-^¯", "0^°", "+-±", "2^²", "3^³", "''´", "/Uµ", "P!¶", ".^·", ",,¸",
1786 "1^¹", "O_º", ">>»", "14¼", "12½", "34¾", "??¿", "`AÀ", "'AÁ", "^AÂ",
1787 "~AÃ", "\"AÄ", "*AÅ", "AEÆ", ",CÇ", "`EÈ", "'EÉ", "^EÊ", "\"EË",
1788 "`IÌ", "'IÍ", "^IÎ", "\"IÏ", "-DÐ", "~NÑ", "`OÒ", "'OÓ", "^OÔ",
1789 "~OÕ", "\"OÖ", "XX×", "/OØ", "`UÙ", "'UÚ", "^UÛ", "\"UÜ", "'YÝ",
1790 "HTÞ", "ssß", "`aà", "'aá", "^aâ", "~aã", "\"aä", "*aå", "aeæ", ",cç",
1791 "`eè", "'eé", "^eê", "\"eë", "`iì", "'ií", "^iî", "\"iï", "-dð", "~nñ",
1792 "`oò", "'oó", "^oô", "~oõ", "\"oö", ":-÷", "o/ø", "`uù", "'uú", "^uû",
1793 "\"uü", "'yý", "htþ", "\"yÿ",
1797 static int recurse = 0;
1800 for(c=composetbl; *c; c++) {
1801 if( (*c)[0] == first && (*c)[1] == second)
1803 return (*c)[2] & 0xFF;
1810 nc = check_compose(second, first);
1812 nc = check_compose(toupper(first), toupper(second));
1814 nc = check_compose(toupper(second), toupper(first));
1822 * Translate a WM_(SYS)?KEY(UP|DOWN) message into a string of ASCII
1823 * codes. Returns number of bytes used or zero to drop the message
1824 * or -1 to forward the message to windows.
1826 static int TranslateKey(UINT message, WPARAM wParam, LPARAM lParam,
1827 unsigned char *output) {
1829 int scan, left_alt = 0, key_down, shift_state;
1831 unsigned char * p = output;
1833 static WORD keys[3];
1834 static int compose_char = 0;
1835 static WPARAM compose_key = 0;
1837 r = GetKeyboardState(keystate);
1838 if (!r) memset(keystate, 0, sizeof(keystate));
1842 { /* Tell us all about key events */
1843 static BYTE oldstate[256];
1844 static int first = 1;
1847 if(first) memcpy(oldstate, keystate, sizeof(oldstate));
1850 if ((HIWORD(lParam)&(KF_UP|KF_REPEAT))==KF_REPEAT) {
1852 } else if ((HIWORD(lParam)&KF_UP) && scan==(HIWORD(lParam) & 0xFF) ) {
1856 if (wParam >= VK_F1 && wParam <= VK_F20 )
1857 debug(("K_F%d", wParam+1-VK_F1));
1860 case VK_SHIFT: debug(("SHIFT")); break;
1861 case VK_CONTROL: debug(("CTRL")); break;
1862 case VK_MENU: debug(("ALT")); break;
1863 default: debug(("VK_%02x", wParam));
1865 if(message == WM_SYSKEYDOWN || message == WM_SYSKEYUP)
1867 debug((", S%02x", scan=(HIWORD(lParam) & 0xFF) ));
1869 ch = MapVirtualKey(wParam, 2);
1870 if (ch>=' ' && ch<='~') debug((", '%c'", ch));
1871 else if (ch) debug((", $%02x", ch));
1873 if (keys[0]) debug((", KB0=%02x", keys[0]));
1874 if (keys[1]) debug((", KB1=%02x", keys[1]));
1875 if (keys[2]) debug((", KB2=%02x", keys[2]));
1877 if ( (keystate[VK_SHIFT]&0x80)!=0) debug((", S"));
1878 if ( (keystate[VK_CONTROL]&0x80)!=0) debug((", C"));
1879 if ( (HIWORD(lParam)&KF_EXTENDED) ) debug((", E"));
1880 if ( (HIWORD(lParam)&KF_UP) ) debug((", U"));
1883 if ((HIWORD(lParam)&(KF_UP|KF_REPEAT))==KF_REPEAT)
1885 else if ( (HIWORD(lParam)&KF_UP) )
1886 oldstate[wParam&0xFF] ^= 0x80;
1888 oldstate[wParam&0xFF] ^= 0x81;
1890 for(ch=0; ch<256; ch++)
1891 if (oldstate[ch] != keystate[ch])
1892 debug((", M%02x=%02x", ch, keystate[ch]));
1894 memcpy(oldstate, keystate, sizeof(oldstate));
1898 /* Note if AltGr was pressed and if it was used as a compose key */
1899 if (cfg.compose_key) {
1900 if (wParam == VK_MENU && (HIWORD(lParam)&KF_EXTENDED))
1902 keystate[VK_RMENU] = keystate[VK_MENU];
1903 if (!compose_state) compose_key = wParam;
1905 if (wParam == VK_APPS && !compose_state)
1906 compose_key = wParam;
1908 if (wParam == compose_key)
1910 if (compose_state == 0 && (HIWORD(lParam)&(KF_UP|KF_REPEAT))==0)
1912 else if (compose_state == 1 && (HIWORD(lParam)&KF_UP))
1917 else if (compose_state==1 && wParam != VK_CONTROL)
1922 /* Nastyness with NUMLock - Shift-NUMLock is left alone though */
1923 if ( (cfg.funky_type == 3 ||
1924 (cfg.funky_type <= 1 && app_keypad_keys && !cfg.no_applic_k))
1925 && wParam==VK_NUMLOCK && !(keystate[VK_SHIFT]&0x80)) {
1927 wParam = VK_EXECUTE;
1929 /* UnToggle NUMLock */
1930 if ((HIWORD(lParam)&(KF_UP|KF_REPEAT))==0)
1931 keystate[VK_NUMLOCK] ^= 1;
1934 /* And write back the 'adjusted' state */
1935 SetKeyboardState (keystate);
1938 /* Disable Auto repeat if required */
1939 if (repeat_off && (HIWORD(lParam)&(KF_UP|KF_REPEAT))==KF_REPEAT)
1942 if ((HIWORD(lParam)&KF_ALTDOWN) && (keystate[VK_RMENU]&0x80) == 0)
1945 key_down = ((HIWORD(lParam)&KF_UP)==0);
1947 /* Make sure Ctrl-ALT is not the same as AltGr for ToAscii */
1948 if (left_alt && (keystate[VK_CONTROL]&0x80))
1949 keystate[VK_MENU] = 0;
1951 scan = (HIWORD(lParam) & (KF_UP | KF_EXTENDED | 0xFF));
1952 shift_state = ((keystate[VK_SHIFT]&0x80)!=0)
1953 + ((keystate[VK_CONTROL]&0x80)!=0)*2;
1956 * Record that we pressed key so the scroll window can be reset, but
1957 * be careful to avoid Shift-UP/Down
1959 if( wParam != VK_SHIFT && wParam != VK_PRIOR && wParam != VK_NEXT ) {
1963 /* Make sure we're not pasting */
1964 if (key_down) term_nopaste();
1966 if (compose_state>1 && left_alt) compose_state = 0;
1968 /* Sanitize the number pad if not using a PC NumPad */
1969 if( left_alt || (app_keypad_keys && !cfg.no_applic_k
1970 && cfg.funky_type != 2)
1971 || cfg.funky_type == 3 || cfg.nethack_keypad || compose_state )
1973 if ((HIWORD(lParam)&KF_EXTENDED) == 0)
1978 case VK_INSERT: nParam = VK_NUMPAD0; break;
1979 case VK_END: nParam = VK_NUMPAD1; break;
1980 case VK_DOWN: nParam = VK_NUMPAD2; break;
1981 case VK_NEXT: nParam = VK_NUMPAD3; break;
1982 case VK_LEFT: nParam = VK_NUMPAD4; break;
1983 case VK_CLEAR: nParam = VK_NUMPAD5; break;
1984 case VK_RIGHT: nParam = VK_NUMPAD6; break;
1985 case VK_HOME: nParam = VK_NUMPAD7; break;
1986 case VK_UP: nParam = VK_NUMPAD8; break;
1987 case VK_PRIOR: nParam = VK_NUMPAD9; break;
1988 case VK_DELETE: nParam = VK_DECIMAL; break;
1992 if (keystate[VK_NUMLOCK]&1) shift_state |= 1;
1998 /* If a key is pressed and AltGr is not active */
1999 if (key_down && (keystate[VK_RMENU]&0x80) == 0 && !compose_state)
2001 /* Okay, prepare for most alts then ...*/
2002 if (left_alt) *p++ = '\033';
2004 /* Lets see if it's a pattern we know all about ... */
2005 if (wParam == VK_PRIOR && shift_state == 1) {
2006 SendMessage (hwnd, WM_VSCROLL, SB_PAGEUP, 0);
2009 if (wParam == VK_NEXT && shift_state == 1) {
2010 SendMessage (hwnd, WM_VSCROLL, SB_PAGEDOWN, 0);
2013 if (wParam == VK_INSERT && shift_state == 1) {
2014 term_mouse (MB_PASTE, MA_CLICK, 0, 0);
2015 term_mouse (MB_PASTE, MA_RELEASE, 0, 0);
2018 if (left_alt && wParam == VK_F4 && cfg.alt_f4) {
2021 if (left_alt && wParam == VK_SPACE && cfg.alt_space) {
2023 SendMessage (hwnd, WM_SYSCOMMAND, SC_KEYMENU, 0);
2026 /* Control-Numlock for app-keypad mode switch */
2027 if (wParam == VK_PAUSE && shift_state == 2) {
2028 app_keypad_keys ^= 1;
2032 /* Nethack keypad */
2033 if (cfg.nethack_keypad && !left_alt) {
2035 case VK_NUMPAD1: *p++ = shift_state ? 'B': 'b'; return p-output;
2036 case VK_NUMPAD2: *p++ = shift_state ? 'J': 'j'; return p-output;
2037 case VK_NUMPAD3: *p++ = shift_state ? 'N': 'n'; return p-output;
2038 case VK_NUMPAD4: *p++ = shift_state ? 'H': 'h'; return p-output;
2039 case VK_NUMPAD5: *p++ = shift_state ? '.': '.'; return p-output;
2040 case VK_NUMPAD6: *p++ = shift_state ? 'L': 'l'; return p-output;
2041 case VK_NUMPAD7: *p++ = shift_state ? 'Y': 'y'; return p-output;
2042 case VK_NUMPAD8: *p++ = shift_state ? 'K': 'k'; return p-output;
2043 case VK_NUMPAD9: *p++ = shift_state ? 'U': 'u'; return p-output;
2047 /* Application Keypad */
2051 if ( cfg.funky_type == 3 ||
2052 ( cfg.funky_type <= 1 &&
2053 app_keypad_keys && !cfg.no_applic_k)) switch(wParam) {
2054 case VK_EXECUTE: xkey = 'P'; break;
2055 case VK_DIVIDE: xkey = 'Q'; break;
2056 case VK_MULTIPLY:xkey = 'R'; break;
2057 case VK_SUBTRACT:xkey = 'S'; break;
2059 if(app_keypad_keys && !cfg.no_applic_k) switch(wParam) {
2060 case VK_NUMPAD0: xkey = 'p'; break;
2061 case VK_NUMPAD1: xkey = 'q'; break;
2062 case VK_NUMPAD2: xkey = 'r'; break;
2063 case VK_NUMPAD3: xkey = 's'; break;
2064 case VK_NUMPAD4: xkey = 't'; break;
2065 case VK_NUMPAD5: xkey = 'u'; break;
2066 case VK_NUMPAD6: xkey = 'v'; break;
2067 case VK_NUMPAD7: xkey = 'w'; break;
2068 case VK_NUMPAD8: xkey = 'x'; break;
2069 case VK_NUMPAD9: xkey = 'y'; break;
2071 case VK_DECIMAL: xkey = 'n'; break;
2072 case VK_ADD: if(cfg.funky_type==2) {
2073 if(shift_state) xkey = 'l';
2075 } else if(shift_state) xkey = 'm';
2079 case VK_DIVIDE: if(cfg.funky_type==2) xkey = 'o'; break;
2080 case VK_MULTIPLY:if(cfg.funky_type==2) xkey = 'j'; break;
2081 case VK_SUBTRACT:if(cfg.funky_type==2) xkey = 'm'; break;
2084 if (HIWORD(lParam)&KF_EXTENDED)
2092 if (xkey>='P' && xkey<='S')
2093 p += sprintf((char *)p, "\x1B%c", xkey);
2095 p += sprintf((char *)p, "\x1B?%c", xkey);
2098 p += sprintf((char *)p, "\x1BO%c", xkey);
2103 if (wParam == VK_BACK && shift_state == 0 ) /* Backspace */
2105 *p++ = (cfg.bksp_is_delete ? 0x7F : 0x08);
2108 if (wParam == VK_TAB && shift_state == 1 ) /* Shift tab */
2110 *p++ = 0x1B; *p++ = '['; *p++ = 'Z'; return p - output;
2112 if (wParam == VK_SPACE && shift_state == 2 ) /* Ctrl-Space */
2114 *p++ = 0; return p - output;
2116 if (wParam == VK_SPACE && shift_state == 3 ) /* Ctrl-Shift-Space */
2118 *p++ = 160; return p - output;
2120 if (wParam == VK_CANCEL && shift_state == 2 ) /* Ctrl-Break */
2122 *p++ = 3; return p - output;
2124 /* Control-2 to Control-8 are special */
2125 if (shift_state == 2 && wParam >= '2' && wParam <= '8')
2127 *p++ = "\000\033\034\035\036\037\177"[wParam-'2'];
2130 if (shift_state == 2 && wParam == 0xBD) {
2134 if (shift_state == 2 && wParam == 0xDF) {
2138 if (shift_state == 0 && wParam == VK_RETURN && cr_lf_return) {
2139 *p++ = '\r'; *p++ = '\n';
2144 * Next, all the keys that do tilde codes. (ESC '[' nn '~',
2145 * for integer decimal nn.)
2147 * We also deal with the weird ones here. Linux VCs replace F1
2148 * to F5 by ESC [ [ A to ESC [ [ E. rxvt doesn't do _that_, but
2149 * does replace Home and End (1~ and 4~) by ESC [ H and ESC O w
2154 case VK_F1: code = (keystate[VK_SHIFT] & 0x80 ? 23 : 11); break;
2155 case VK_F2: code = (keystate[VK_SHIFT] & 0x80 ? 24 : 12); break;
2156 case VK_F3: code = (keystate[VK_SHIFT] & 0x80 ? 25 : 13); break;
2157 case VK_F4: code = (keystate[VK_SHIFT] & 0x80 ? 26 : 14); break;
2158 case VK_F5: code = (keystate[VK_SHIFT] & 0x80 ? 28 : 15); break;
2159 case VK_F6: code = (keystate[VK_SHIFT] & 0x80 ? 29 : 17); break;
2160 case VK_F7: code = (keystate[VK_SHIFT] & 0x80 ? 31 : 18); break;
2161 case VK_F8: code = (keystate[VK_SHIFT] & 0x80 ? 32 : 19); break;
2162 case VK_F9: code = (keystate[VK_SHIFT] & 0x80 ? 33 : 20); break;
2163 case VK_F10: code = (keystate[VK_SHIFT] & 0x80 ? 34 : 21); break;
2164 case VK_F11: code = 23; break;
2165 case VK_F12: code = 24; break;
2166 case VK_F13: code = 25; break;
2167 case VK_F14: code = 26; break;
2168 case VK_F15: code = 28; break;
2169 case VK_F16: code = 29; break;
2170 case VK_F17: code = 31; break;
2171 case VK_F18: code = 32; break;
2172 case VK_F19: code = 33; break;
2173 case VK_F20: code = 34; break;
2174 case VK_HOME: code = 1; break;
2175 case VK_INSERT: code = 2; break;
2176 case VK_DELETE: code = 3; break;
2177 case VK_END: code = 4; break;
2178 case VK_PRIOR: code = 5; break;
2179 case VK_NEXT: code = 6; break;
2181 /* Reorder edit keys to physical order */
2182 if (cfg.funky_type == 3 && code <= 6 ) code = "\0\2\1\4\5\3\6"[code];
2184 if (cfg.funky_type == 1 && code >= 11 && code <= 15) {
2185 p += sprintf((char *)p, "\x1B[[%c", code + 'A' - 11);
2188 if (cfg.funky_type == 2 && code >= 11 && code <= 14) {
2190 p += sprintf((char *)p, "\x1B%c", code + 'P' - 11);
2192 p += sprintf((char *)p, "\x1BO%c", code + 'P' - 11);
2195 if (cfg.rxvt_homeend && (code == 1 || code == 4)) {
2196 p += sprintf((char *)p, code == 1 ? "\x1B[H" : "\x1BOw");
2200 p += sprintf((char *)p, "\x1B[%d~", code);
2205 * Now the remaining keys (arrows and Keypad 5. Keypad 5 for
2206 * some reason seems to send VK_CLEAR to Windows...).
2211 case VK_UP: xkey = 'A'; break;
2212 case VK_DOWN: xkey = 'B'; break;
2213 case VK_RIGHT: xkey = 'C'; break;
2214 case VK_LEFT: xkey = 'D'; break;
2215 case VK_CLEAR: xkey = 'G'; break;
2220 p += sprintf((char *)p, "\x1B%c", xkey);
2221 else if (app_cursor_keys && !cfg.no_applic_c)
2222 p += sprintf((char *)p, "\x1BO%c", xkey);
2224 p += sprintf((char *)p, "\x1B[%c", xkey);
2230 * Finally, deal with Return ourselves. (Win95 seems to
2231 * foul it up when Alt is pressed, for some reason.)
2233 if (wParam == VK_RETURN) /* Return */
2240 /* Okay we've done everything interesting; let windows deal with
2241 * the boring stuff */
2243 BOOL capsOn=keystate[VK_CAPITAL] !=0;
2245 /* helg: clear CAPS LOCK state if caps lock switches to cyrillic */
2246 if(cfg.xlat_capslockcyr)
2247 keystate[VK_CAPITAL] = 0;
2249 r = ToAscii (wParam, scan, keystate, keys, 0);
2255 unsigned char ch = (unsigned char)keys[i];
2257 if (compose_state==2 && (ch&0x80) == 0 && ch>' ') {
2262 if (compose_state==3 && (ch&0x80) == 0 && ch>' ') {
2266 if ((nc=check_compose(compose_char,ch)) == -1)
2268 MessageBeep(MB_ICONHAND);
2271 *p++ = xlat_kbd2tty((unsigned char)nc);
2277 if( left_alt && key_down ) *p++ = '\033';
2283 ch = xlat_latkbd2win(ch);
2284 *p++ = xlat_kbd2tty(ch);
2288 /* This is so the ALT-Numpad and dead keys work correctly. */
2295 /* This stops ALT press-release doing a 'COMMAND MENU' function */
2296 if (!cfg.alt_only) {
2297 if (message == WM_SYSKEYUP && wParam == VK_MENU)
2304 void set_title (char *title) {
2305 sfree (window_name);
2306 window_name = smalloc(1+strlen(title));
2307 strcpy (window_name, title);
2308 if (cfg.win_name_always || !IsIconic(hwnd))
2309 SetWindowText (hwnd, title);
2312 void set_icon (char *title) {
2314 icon_name = smalloc(1+strlen(title));
2315 strcpy (icon_name, title);
2316 if (!cfg.win_name_always && IsIconic(hwnd))
2317 SetWindowText (hwnd, title);
2320 void set_sbar (int total, int start, int page) {
2323 if (!cfg.scrollbar) return;
2325 si.cbSize = sizeof(si);
2326 si.fMask = SIF_ALL | SIF_DISABLENOSCROLL;
2328 si.nMax = total - 1;
2332 SetScrollInfo (hwnd, SB_VERT, &si, TRUE);
2335 Context get_ctx(void) {
2340 SelectPalette (hdc, pal, FALSE);
2346 void free_ctx (Context ctx) {
2347 SelectPalette (ctx, GetStockObject (DEFAULT_PALETTE), FALSE);
2348 ReleaseDC (hwnd, ctx);
2351 static void real_palette_set (int n, int r, int g, int b) {
2353 logpal->palPalEntry[n].peRed = r;
2354 logpal->palPalEntry[n].peGreen = g;
2355 logpal->palPalEntry[n].peBlue = b;
2356 logpal->palPalEntry[n].peFlags = PC_NOCOLLAPSE;
2357 colours[n] = PALETTERGB(r, g, b);
2358 SetPaletteEntries (pal, 0, NCOLOURS, logpal->palPalEntry);
2360 colours[n] = RGB(r, g, b);
2363 void palette_set (int n, int r, int g, int b) {
2364 static const int first[21] = {
2365 0, 2, 4, 6, 8, 10, 12, 14,
2366 1, 3, 5, 7, 9, 11, 13, 15,
2369 real_palette_set (first[n], r, g, b);
2371 real_palette_set (first[n]+1, r, g, b);
2373 HDC hdc = get_ctx();
2374 UnrealizeObject (pal);
2375 RealizePalette (hdc);
2380 void palette_reset (void) {
2383 for (i = 0; i < NCOLOURS; i++) {
2385 logpal->palPalEntry[i].peRed = defpal[i].rgbtRed;
2386 logpal->palPalEntry[i].peGreen = defpal[i].rgbtGreen;
2387 logpal->palPalEntry[i].peBlue = defpal[i].rgbtBlue;
2388 logpal->palPalEntry[i].peFlags = 0;
2389 colours[i] = PALETTERGB(defpal[i].rgbtRed,
2390 defpal[i].rgbtGreen,
2391 defpal[i].rgbtBlue);
2393 colours[i] = RGB(defpal[i].rgbtRed,
2394 defpal[i].rgbtGreen,
2395 defpal[i].rgbtBlue);
2400 SetPaletteEntries (pal, 0, NCOLOURS, logpal->palPalEntry);
2402 RealizePalette (hdc);
2407 void write_clip (void *data, int len, int must_deselect) {
2411 clipdata = GlobalAlloc (GMEM_DDESHARE | GMEM_MOVEABLE, len + 1);
2414 lock = GlobalLock (clipdata);
2417 memcpy (lock, data, len);
2418 ((unsigned char *) lock) [len] = 0;
2419 GlobalUnlock (clipdata);
2422 SendMessage (hwnd, WM_IGNORE_CLIP, TRUE, 0);
2424 if (OpenClipboard (hwnd)) {
2426 SetClipboardData (CF_TEXT, clipdata);
2429 GlobalFree (clipdata);
2432 SendMessage (hwnd, WM_IGNORE_CLIP, FALSE, 0);
2435 void get_clip (void **p, int *len) {
2436 static HGLOBAL clipdata = NULL;
2440 GlobalUnlock (clipdata);
2444 if (OpenClipboard (NULL)) {
2445 clipdata = GetClipboardData (CF_TEXT);
2448 *p = GlobalLock (clipdata);
2462 * Move `lines' lines from position `from' to position `to' in the
2465 void optimised_move (int to, int from, int lines) {
2469 min = (to < from ? to : from);
2470 max = to + from - min;
2472 r.left = 0; r.right = cols * font_width;
2473 r.top = min * font_height; r.bottom = (max+lines) * font_height;
2474 ScrollWindow (hwnd, 0, (to - from) * font_height, &r, &r);
2478 * Print a message box and perform a fatal exit.
2480 void fatalbox(char *fmt, ...) {
2485 vsprintf(stuff, fmt, ap);
2487 MessageBox(hwnd, stuff, "PuTTY Fatal Error", MB_ICONERROR | MB_OK);
2494 void beep(int errorbeep) {
2495 static long last_beep = 0;
2496 long now, beep_diff;
2498 now = GetTickCount();
2499 beep_diff = now-last_beep;
2501 /* Make sure we only respond to one beep per packet or so */
2502 if (beep_diff>=0 && beep_diff<50)
2506 MessageBeep(MB_ICONHAND);
2510 last_beep = GetTickCount();