#include <windows.h>
#include <imm.h>
#include <commctrl.h>
+#include <richedit.h>
#include <mmsystem.h>
#ifndef AUTO_WINSOCK
#ifdef WINSOCK_TWO
#endif
#endif
-#if (WINVER < 0x0500) && !defined(NO_MULTIMON)
-#define COMPILE_MULTIMON_STUBS
-#include <multimon.h>
-#endif
-
#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#include <time.h>
+#include <assert.h>
#define PUTTY_DO_GLOBALS /* actually _define_ globals */
#include "putty.h"
/* Window layout information */
static void reset_window(int);
-static int full_screen = 0, want_full_screen = 0;
+static int full_screen = 0;
static int extra_width, extra_height;
static int font_width, font_height, font_dualwidth;
static int offset_width, offset_height;
static int was_zoomed = 0;
-static int was_full_screen = 0;
static int prev_rows, prev_cols;
-static int pre_fs_rows, pre_fs_cols;
-static LONG old_wind_style;
-static WINDOWPLACEMENT old_wind_placement;
-
static int pending_netevent = 0;
static WPARAM pend_netevent_wParam = 0;
static LPARAM pend_netevent_lParam = 0;
#define FONT_MAXNO 0x2F
#define FONT_SHIFT 5
static HFONT fonts[FONT_MAXNO];
+static LOGFONT lfont;
static int fontflag[FONT_MAXNO];
static enum {
BOLD_COLOURS, BOLD_SHADOW, BOLD_FONT
AppendMenu(m, MF_ENABLED, IDM_CLRSB, "C&lear Scrollback");
AppendMenu(m, MF_ENABLED, IDM_RESET, "Rese&t Terminal");
AppendMenu(m, MF_SEPARATOR, 0, 0);
- AppendMenu(m, MF_ENABLED, IDM_FULLSCREEN, "&Full Screen");
+ AppendMenu(m, (cfg.resize_action == RESIZE_DISABLED) ?
+ MF_GRAYED : MF_ENABLED, IDM_FULLSCREEN, "&Full Screen");
AppendMenu(m, MF_SEPARATOR, 0, 0);
AppendMenu(m, MF_ENABLED, IDM_ABOUT, "&About PuTTY");
}
f(FONT_NORMAL, cfg.fontcharset, fw_dontcare, FALSE);
+ lfont.lfHeight = font_height;
+ lfont.lfWidth = font_width;
+ lfont.lfEscapement = 0;
+ lfont.lfOrientation = 0;
+ lfont.lfWeight = fw_dontcare;
+ lfont.lfItalic = FALSE;
+ lfont.lfUnderline = FALSE;
+ lfont.lfStrikeOut = FALSE;
+ lfont.lfCharSet = cfg.fontcharset;
+ lfont.lfOutPrecision = OUT_DEFAULT_PRECIS;
+ lfont.lfClipPrecision = CLIP_DEFAULT_PRECIS;
+ lfont.lfQuality = DEFAULT_QUALITY;
+ lfont.lfPitchAndFamily = FIXED_PITCH | FF_DONTCARE;
+ strncpy(lfont.lfFaceName, cfg.font, LF_FACESIZE);
+
SelectObject(hdc, fonts[FONT_NORMAL]);
GetTextMetrics(hdc, &tm);
#endif
}
- if (IsZoomed(hwnd) || full_screen) {
+ if (IsZoomed(hwnd)) {
/* We're fullscreen, this means we must not change the size of
* the window so it's the font size or the terminal itself.
*/
return FALSE;
}
+static int resizing;
+
static LRESULT CALLBACK WndProc(HWND hwnd, UINT message,
WPARAM wParam, LPARAM lParam)
{
HDC hdc;
static int ignore_clip = FALSE;
- static int resizing = FALSE;
static int need_backend_resize = FALSE;
switch (message) {
if (!do_reconfig(hwnd))
break;
- /* If user forcibly disables full-screen, gracefully unzoom */
- if (full_screen && !cfg.fullscreenonaltenter) {
- flip_full_screen();
+ {
+ /* Disable full-screen if resizing forbidden */
+ HMENU m = GetSystemMenu (hwnd, FALSE);
+ EnableMenuItem(m, IDM_FULLSCREEN, MF_BYCOMMAND |
+ (cfg.resize_action == RESIZE_DISABLED)
+ ? MF_GRAYED : MF_ENABLED);
+ /* Gracefully unzoom if necessary */
+ if (full_screen &&
+ (cfg.resize_action == RESIZE_DISABLED)) {
+ flip_full_screen();
+ }
}
if (strcmp(prev_cfg.logfilename, cfg.logfilename) ||
nexflag &= ~(WS_EX_CLIENTEDGE);
nflg = flag;
- if (cfg.scrollbar)
+ if (full_screen ?
+ cfg.scrollbar_in_fullscreen : cfg.scrollbar)
nflg |= WS_VSCROLL;
else
nflg &= ~WS_VSCROLL;
case IDM_ABOUT:
showabout(hwnd);
break;
+ case SC_MOUSEMENU:
+ /*
+ * We get this if the System menu has been activated
+ * using the mouse.
+ */
+ show_mouseptr(1);
+ break;
case SC_KEYMENU:
/*
- * We get this if the System menu has been activated.
- * This might happen from within TranslateKey, in which
- * case it really wants to be followed by a `space'
- * character to actually _bring the menu up_ rather
- * than just sitting there in `ready to appear' state.
+ * We get this if the System menu has been activated
+ * using the keyboard. This might happen from within
+ * TranslateKey, in which case it really wants to be
+ * followed by a `space' character to actually _bring
+ * the menu up_ rather than just sitting there in
+ * `ready to appear' state.
*/
+ show_mouseptr(1); /* make sure pointer is visible */
if( lParam == 0 )
PostMessage(hwnd, WM_CHAR, ' ', 0);
break;
button = press = 0; /* shouldn't happen */
}
show_mouseptr(1);
+ /*
+ * Special case: in full-screen mode, if the left
+ * button is clicked in the very top left corner of the
+ * window, we put up the System menu instead of doing
+ * selection.
+ */
+ if (full_screen && press && button == MBT_LEFT &&
+ X_POS(lParam) == 0 && Y_POS(lParam) == 0) {
+ SendMessage(hwnd, WM_SYSCOMMAND, SC_MOUSEMENU, 0);
+ return 0;
+ }
if (press) {
click(button,
TO_CHR_X(X_POS(lParam)), TO_CHR_Y(Y_POS(lParam)),
if (cfg.resize_action != RESIZE_FONT)
term_size(prev_rows, prev_cols, cfg.savelines);
reset_window(0);
- } else if (was_full_screen) {
- was_full_screen = 0;
- if (cfg.resize_action != RESIZE_FONT)
- term_size(pre_fs_rows, pre_fs_cols, cfg.savelines);
- reset_window(0);
}
/* This is an unexpected resize, these will normally happen
* if the window is too large. Probably either the user
kbd_codepage = atoi(lbuf);
}
break;
+ case WM_IME_NOTIFY:
+ if(wParam == IMN_SETOPENSTATUS) {
+ HIMC hImc = ImmGetContext(hwnd);
+ ImmSetCompositionFont(hImc, &lfont);
+ ImmReleaseContext(hwnd, hImc);
+ return 0;
+ }
+ break;
case WM_IME_COMPOSITION:
{
HIMC hIMC;
/* we should have the IMM functions */
hIMC = ImmGetContext(hwnd);
cf.dwStyle = CFS_POINT;
- cf.ptCurrentPos.x = x * font_width;
- cf.ptCurrentPos.y = y * font_height;
+ cf.ptCurrentPos.x = x * font_width + offset_width;
+ cf.ptCurrentPos.y = y * font_height + offset_height;
ImmSetCompositionWindow(hIMC, &cf);
ImmReleaseContext(hwnd, hIMC);
* Record that we pressed key so the scroll window can be reset, but
* be careful to avoid Shift-UP/Down
*/
- if (wParam != VK_SHIFT && wParam != VK_PRIOR && wParam != VK_NEXT) {
+ if (wParam != VK_SHIFT && wParam != VK_PRIOR && wParam != VK_NEXT &&
+ wParam != VK_MENU && wParam != VK_CONTROL) {
seen_key_event = 1;
}
SendMessage(hwnd, WM_SYSCOMMAND, SC_KEYMENU, 0);
return -1;
}
- if (left_alt && wParam == VK_RETURN && cfg.fullscreenonaltenter) {
+ if (left_alt && wParam == VK_RETURN && cfg.fullscreenonaltenter &&
+ (cfg.resize_action != RESIZE_DISABLED)) {
flip_full_screen();
return -1;
}
*/
void write_clip(wchar_t * data, int len, int must_deselect)
{
- HGLOBAL clipdata;
- HGLOBAL clipdata2;
+ HGLOBAL clipdata, clipdata2, clipdata3;
int len2;
- void *lock, *lock2;
+ void *lock, *lock2, *lock3;
len2 = WideCharToMultiByte(CP_ACP, 0, data, len, 0, 0, NULL, NULL);
len * sizeof(wchar_t));
clipdata2 = GlobalAlloc(GMEM_DDESHARE | GMEM_MOVEABLE, len2);
- if (!clipdata || !clipdata2) {
+ if (!clipdata || !clipdata2 || !clipdata3) {
if (clipdata)
GlobalFree(clipdata);
if (clipdata2)
GlobalFree(clipdata2);
+ if (clipdata3)
+ GlobalFree(clipdata3);
return;
}
if (!(lock = GlobalLock(clipdata)))
memcpy(lock, data, len * sizeof(wchar_t));
WideCharToMultiByte(CP_ACP, 0, data, len, lock2, len2, NULL, NULL);
+ if (cfg.rtf_paste) {
+ wchar_t unitab[256];
+ char *rtf = NULL;
+ unsigned char *tdata = (unsigned char *)lock2;
+ wchar_t *udata = (wchar_t *)lock;
+ int rtflen = 0, uindex = 0, tindex = 0;
+ int rtfsize = 0;
+ int multilen, blen, alen, totallen, i;
+ char before[16], after[4];
+
+ get_unitab(CP_ACP, unitab, 0);
+
+ rtfsize = 100 + strlen(cfg.font);
+ rtf = smalloc(rtfsize);
+ sprintf(rtf, "{\\rtf1\\ansi%d{\\fonttbl\\f0\\fmodern %s;}\\f0",
+ GetACP(), cfg.font);
+ rtflen = strlen(rtf);
+
+ /*
+ * We want to construct a piece of RTF that specifies the
+ * same Unicode text. To do this we will read back in
+ * parallel from the Unicode data in `udata' and the
+ * non-Unicode data in `tdata'. For each character in
+ * `tdata' which becomes the right thing in `udata' when
+ * looked up in `unitab', we just copy straight over from
+ * tdata. For each one that doesn't, we must WCToMB it
+ * individually and produce a \u escape sequence.
+ *
+ * It would probably be more robust to just bite the bullet
+ * and WCToMB each individual Unicode character one by one,
+ * then MBToWC each one back to see if it was an accurate
+ * translation; but that strikes me as a horrifying number
+ * of Windows API calls so I want to see if this faster way
+ * will work. If it screws up badly we can always revert to
+ * the simple and slow way.
+ */
+ while (tindex < len2 && uindex < len &&
+ tdata[tindex] && udata[uindex]) {
+ if (tindex + 1 < len2 &&
+ tdata[tindex] == '\r' &&
+ tdata[tindex+1] == '\n') {
+ tindex++;
+ uindex++;
+ }
+ if (unitab[tdata[tindex]] == udata[uindex]) {
+ multilen = 1;
+ before[0] = '\0';
+ after[0] = '\0';
+ blen = alen = 0;
+ } else {
+ multilen = WideCharToMultiByte(CP_ACP, 0, unitab+uindex, 1,
+ NULL, 0, NULL, NULL);
+ if (multilen != 1) {
+ blen = sprintf(before, "{\\uc%d\\u%d", multilen,
+ udata[uindex]);
+ alen = 1; strcpy(after, "}");
+ } else {
+ blen = sprintf(before, "\\u%d", udata[uindex]);
+ alen = 0; after[0] = '\0';
+ }
+ }
+ assert(tindex + multilen <= len2);
+ totallen = blen + alen;
+ for (i = 0; i < multilen; i++) {
+ if (tdata[tindex+i] == '\\' ||
+ tdata[tindex+i] == '{' ||
+ tdata[tindex+i] == '}')
+ totallen += 2;
+ else if (tdata[tindex+i] == 0x0D || tdata[tindex+i] == 0x0A)
+ totallen += 6; /* \par\r\n */
+ else if (tdata[tindex+i] > 0x7E || tdata[tindex+i] < 0x20)
+ totallen += 4;
+ else
+ totallen++;
+ }
+
+ if (rtfsize < rtflen + totallen + 3) {
+ rtfsize = rtflen + totallen + 512;
+ rtf = srealloc(rtf, rtfsize);
+ }
+
+ strcpy(rtf + rtflen, before); rtflen += blen;
+ for (i = 0; i < multilen; i++) {
+ if (tdata[tindex+i] == '\\' ||
+ tdata[tindex+i] == '{' ||
+ tdata[tindex+i] == '}') {
+ rtf[rtflen++] = '\\';
+ rtf[rtflen++] = tdata[tindex+i];
+ } else if (tdata[tindex+i] == 0x0D || tdata[tindex+i] == 0x0A) {
+ rtflen += sprintf(rtf+rtflen, "\\par\r\n");
+ } else if (tdata[tindex+i] > 0x7E || tdata[tindex+i] < 0x20) {
+ rtflen += sprintf(rtf+rtflen, "\\'%02x", tdata[tindex+i]);
+ } else {
+ rtf[rtflen++] = tdata[tindex+i];
+ }
+ }
+ strcpy(rtf + rtflen, after); rtflen += alen;
+
+ tindex += multilen;
+ uindex++;
+ }
+
+ strcpy(rtf + rtflen, "}");
+ rtflen += 2;
+
+ clipdata3 = GlobalAlloc(GMEM_DDESHARE | GMEM_MOVEABLE, rtflen);
+ if (clipdata3 && (lock3 = GlobalLock(clipdata3)) != NULL) {
+ strcpy(lock3, rtf);
+ GlobalUnlock(clipdata3);
+ }
+ sfree(rtf);
+ } else
+ clipdata3 = NULL;
+
GlobalUnlock(clipdata);
GlobalUnlock(clipdata2);
EmptyClipboard();
SetClipboardData(CF_UNICODETEXT, clipdata);
SetClipboardData(CF_TEXT, clipdata2);
+ if (clipdata3)
+ SetClipboardData(RegisterClipboardFormat(CF_RTF), clipdata3);
CloseClipboard();
} else {
GlobalFree(clipdata);
*/
static void flip_full_screen(void)
{
- want_full_screen = !want_full_screen;
-
- if (full_screen == want_full_screen)
- return;
+ WINDOWPLACEMENT wp;
+ LONG style;
- full_screen = want_full_screen;
+ wp.length = sizeof(wp);
+ GetWindowPlacement(hwnd, &wp);
- old_wind_placement.length = sizeof(old_wind_placement);
+ full_screen = !full_screen;
if (full_screen) {
- int x, y, cx, cy;
-#if !defined(NO_MULTIMON) && defined(MONITOR_DEFAULTTONEAREST)
- /* The multi-monitor safe way of doing things */
- HMONITOR mon;
- MONITORINFO mi;
-
- mon = MonitorFromWindow(hwnd, MONITOR_DEFAULTTONEAREST);
- mi.cbSize = sizeof(mi);
- GetMonitorInfo(mon, &mi);
- x = mi.rcMonitor.left;
- y = mi.rcMonitor.top;
- cx = mi.rcMonitor.right;
- cy = mi.rcMonitor.bottom;
-#else
- /* good old fashioned way of doing it */
- x = 0;
- y = 0;
- cx = GetSystemMetrics(SM_CXSCREEN);
- cy = GetSystemMetrics(SM_CYSCREEN);
-#endif
+ if (wp.showCmd == SW_SHOWMAXIMIZED) {
+ /* Ooops it was already 'zoomed' we have to unzoom it before
+ * everything will work right.
+ */
+ wp.showCmd = SW_SHOWNORMAL;
+ SetWindowPlacement(hwnd, &wp);
+ }
+
+ style = GetWindowLong(hwnd, GWL_STYLE) & ~WS_CAPTION;
+ style &= ~WS_VSCROLL;
+ if (cfg.scrollbar_in_fullscreen)
+ style |= WS_VSCROLL;
+ SetWindowLong(hwnd, GWL_STYLE, style);
+
+ /* This seems to be needed otherwize explorer doesn't notice
+ * we want to go fullscreen and it's bar is still visible
+ */
+ SetWindowPos(hwnd, NULL, 0, 0, 0, 0,
+ SWP_NOACTIVATE | SWP_NOCOPYBITS |
+ SWP_NOMOVE | SWP_NOSIZE | SWP_NOZORDER |
+ SWP_FRAMECHANGED);
- /* save rows for when we "restore" back down again */
- pre_fs_rows = rows;
- pre_fs_cols = cols;
-
- GetWindowPlacement(hwnd, &old_wind_placement);
- SetWindowLong(hwnd, GWL_STYLE,
- GetWindowLong(hwnd, GWL_STYLE)
- & ~((cfg.scrollbar_in_fullscreen ? 0 : WS_VSCROLL)
- | WS_CAPTION | WS_BORDER | WS_THICKFRAME));
- /* become topmost */
- SetWindowPos(hwnd, HWND_TOP, x, y, cx, cy, SWP_FRAMECHANGED);
+ wp.showCmd = SW_SHOWMAXIMIZED;
+ SetWindowPlacement(hwnd, &wp);
} else {
- was_full_screen = 1;
- SetWindowLong(hwnd, GWL_STYLE,
- GetWindowLong(hwnd, GWL_STYLE)
- | (cfg.scrollbar ? WS_VSCROLL : 0)
- | WS_CAPTION | WS_BORDER | WS_THICKFRAME);
- SetWindowPos(hwnd, HWND_TOP, 0, 0, 0, 0,
- SWP_NOMOVE|SWP_NOSIZE|SWP_FRAMECHANGED);
- SetWindowPlacement(hwnd,&old_wind_placement);
+ style = GetWindowLong(hwnd, GWL_STYLE) | WS_CAPTION;
+ style &= ~WS_VSCROLL;
+ if (cfg.scrollbar)
+ style |= WS_VSCROLL;
+ SetWindowLong(hwnd, GWL_STYLE, style);
+
+ /* Don't need to do a SetWindowPos as the resize will force a
+ * full redraw.
+ */
+ wp.showCmd = SW_SHOWNORMAL;
+ SetWindowPlacement(hwnd, &wp);
}
+
CheckMenuItem(GetSystemMenu(hwnd, FALSE), IDM_FULLSCREEN,
MF_BYCOMMAND| full_screen ? MF_CHECKED : MF_UNCHECKED);
}
+
+/*
+ * Minimise or restore the window in response to a server-side
+ * request.
+ */
+void set_iconic(int iconic)
+{
+ if (IsIconic(hwnd)) {
+ if (!iconic)
+ ShowWindow(hwnd, SW_RESTORE);
+ } else {
+ if (iconic)
+ ShowWindow(hwnd, SW_MINIMIZE);
+ }
+}
+
+/*
+ * Move the window in response to a server-side request.
+ */
+void move_window(int x, int y)
+{
+ SetWindowPos(hwnd, NULL, x, y, 0, 0, SWP_NOSIZE | SWP_NOZORDER);
+}
+
+/*
+ * Move the window to the top or bottom of the z-order in response
+ * to a server-side request.
+ */
+void set_zorder(int top)
+{
+ if (cfg.alwaysontop || full_screen)
+ return; /* ignore */
+ SetWindowPos(hwnd, top ? HWND_TOP : HWND_BOTTOM, 0, 0, 0, 0,
+ SWP_NOMOVE | SWP_NOSIZE);
+}
+
+/*
+ * Refresh the window in response to a server-side request.
+ */
+void refresh_window(void)
+{
+ InvalidateRect(hwnd, NULL, TRUE);
+}
+
+/*
+ * Maximise or restore the window in response to a server-side
+ * request.
+ */
+void set_zoomed(int zoomed)
+{
+ if (IsZoomed(hwnd) || full_screen) {
+ if (!zoomed) {
+ if (full_screen)
+ flip_full_screen();
+ else
+ ShowWindow(hwnd, SW_RESTORE);
+ }
+ } else {
+ if (zoomed)
+ ShowWindow(hwnd, SW_MAXIMIZE);
+ }
+}
+
+/*
+ * Report whether the window is iconic, for terminal reports.
+ */
+int is_iconic(void)
+{
+ return IsIconic(hwnd);
+}
+
+/*
+ * Report the window's position, for terminal reports.
+ */
+void get_window_pos(int *x, int *y)
+{
+ RECT r;
+ GetWindowRect(hwnd, &r);
+ *x = r.left;
+ *y = r.top;
+}
+
+/*
+ * Report the window's pixel size, for terminal reports.
+ */
+void get_window_pixels(int *x, int *y)
+{
+ RECT r;
+ GetWindowRect(hwnd, &r);
+ *x = r.right - r.left;
+ *y = r.bottom - r.top;
+}
+
+/*
+ * Return the window or icon title.
+ */
+char *get_window_title(int icon)
+{
+ return icon ? icon_name : window_name;
+}
projects / u / mdw / putty / blobdiff