#include <windows.h>
#include <imm.h>
#include <commctrl.h>
+#include <richedit.h>
#include <mmsystem.h>
#ifndef AUTO_WINSOCK
#ifdef WINSOCK_TWO
#include <winsock.h>
#endif
#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"
#define IDM_ABOUT 0x0140
#define IDM_SAVEDSESS 0x0150
#define IDM_COPYALL 0x0160
+#define IDM_FULLSCREEN 0x0170
#define IDM_SESSLGP 0x0250 /* log type printable */
#define IDM_SESSLGA 0x0260 /* log type all chars */
/* Window layout information */
static void reset_window(int);
-static int full_screen = 0, extra_width, extra_height;
+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 prev_rows, prev_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;
int exwinmode = 0;
if (!cfg.scrollbar)
winmode &= ~(WS_VSCROLL);
- if (cfg.locksize && cfg.lockfont)
+ if (cfg.resize_action == RESIZE_DISABLED)
winmode &= ~(WS_THICKFRAME | WS_MAXIMIZEBOX);
if (cfg.alwaysontop)
exwinmode |= WS_EX_TOPMOST;
session_closed = FALSE;
/*
- * Set up the input and output buffers.
- */
- inbuf_head = 0;
- outbuf_reap = outbuf_head = 0;
-
- /*
* Prepare the mouse handler.
*/
lastact = MA_NOTHING;
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, MF_SEPARATOR, 0, 0);
AppendMenu(m, MF_ENABLED, IDM_ABOUT, "&About PuTTY");
}
timer_id = 0;
}
HideCaret(hwnd);
- if (inbuf_head)
- term_out();
+ term_out();
term_update();
ShowCaret(hwnd);
/* If the window is maximized supress resizing attempts */
if (IsZoomed(hwnd)) {
- if (cfg.lockfont)
+ if (cfg.resize_action != RESIZE_FONT)
return;
}
- if (cfg.lockfont && cfg.locksize) return;
+ if (cfg.resize_action == RESIZE_DISABLED) return;
if (h == rows && w == cols) return;
/* Sanity checks ... */
term_size(h, w, cfg.savelines);
- if (cfg.lockfont) {
+ if (cfg.resize_action != RESIZE_FONT) {
width = extra_width + font_width * w;
height = extra_height + font_height * h;
extra_width = wr.right - wr.left - cr.right + cr.left;
extra_height = wr.bottom - wr.top - cr.bottom + cr.top;
- if (!cfg.lockfont) {
+ if (cfg.resize_action == RESIZE_FONT) {
if ( font_width != win_width/cols ||
font_height != win_height/rows) {
deinit_fonts();
* window. But that may be too big for the screen which forces us
* to change the terminal.
*/
- if ((cfg.lockfont && reinit==0) || reinit>0) {
+ if ((cfg.resize_action != RESIZE_FONT && reinit==0) || reinit>0) {
offset_width = offset_height = cfg.window_border;
extra_width = wr.right - wr.left - cr.right + cr.left + offset_width*2;
extra_height = wr.bottom - wr.top - cr.bottom + cr.top +offset_height*2;
}
}
-static void click(Mouse_Button b, int x, int y, int shift, int ctrl)
+static void click(Mouse_Button b, int x, int y, int shift, int ctrl, int alt)
{
int thistime = GetMessageTime();
if (send_raw_mouse && !(cfg.mouse_override && shift)) {
lastbtn = MBT_NOTHING;
- term_mouse(b, MA_CLICK, x, y, shift, ctrl);
+ term_mouse(b, MA_CLICK, x, y, shift, ctrl, alt);
return;
}
lastact = MA_CLICK;
}
if (lastact != MA_NOTHING)
- term_mouse(b, lastact, x, y, shift, ctrl);
+ term_mouse(b, lastact, x, y, shift, ctrl, alt);
lasttime = thistime;
}
cursor_visible = show;
}
+static int is_alt_pressed(void)
+{
+ BYTE keystate[256];
+ int r = GetKeyboardState(keystate);
+ if (!r)
+ return FALSE;
+ if (keystate[VK_MENU] & 0x80)
+ return TRUE;
+ if (keystate[VK_RMENU] & 0x80)
+ return TRUE;
+ return FALSE;
+}
+
static LRESULT CALLBACK WndProc(HWND hwnd, UINT message,
WPARAM wParam, LPARAM lParam)
{
case WM_TIMER:
if (pending_netevent)
enact_pending_netevent();
- if (inbuf_head)
- term_out();
+ term_out();
noise_regular();
HideCaret(hwnd);
term_update();
last_movement = now;
}
}
+ net_pending_errors();
return 0;
case WM_CREATE:
break;
if (!do_reconfig(hwnd))
break;
+ /* If user forcibly disables full-screen, gracefully unzoom */
+ if (full_screen && !cfg.fullscreenonaltenter) {
+ flip_full_screen();
+ }
+
if (strcmp(prev_cfg.logfilename, cfg.logfilename) ||
prev_cfg.logtype != cfg.logtype) {
logfclose(); /* reset logging */
* Flush the line discipline's edit buffer in the
* case where local editing has just been disabled.
*/
- ldisc_send(NULL, 0);
+ ldisc_send(NULL, 0, 0);
if (pal)
DeleteObject(pal);
logpal = NULL;
if (cfg.height != prev_cfg.height ||
cfg.width != prev_cfg.width ||
cfg.savelines != prev_cfg.savelines ||
- cfg.locksize )
+ cfg.resize_action != RESIZE_TERM)
term_size(cfg.height, cfg.width, cfg.savelines);
/* Enable or disable the scroll bar, etc */
nflg |= WS_VSCROLL;
else
nflg &= ~WS_VSCROLL;
- if (cfg.locksize && cfg.lockfont)
+ if (cfg.resize_action == RESIZE_DISABLED)
nflg &= ~(WS_THICKFRAME | WS_MAXIMIZEBOX);
else
nflg |= (WS_THICKFRAME | WS_MAXIMIZEBOX);
}
/* Oops */
- if (cfg.locksize && cfg.lockfont && IsZoomed(hwnd)) {
+ if (cfg.resize_action == RESIZE_DISABLED && IsZoomed(hwnd)) {
force_normal(hwnd);
init_lvl = 2;
}
cfg.fontcharset != prev_cfg.fontcharset ||
cfg.vtmode != prev_cfg.vtmode ||
cfg.bold_colour != prev_cfg.bold_colour ||
- (cfg.lockfont && !prev_cfg.lockfont))
+ (cfg.resize_action != RESIZE_FONT &&
+ prev_cfg.resize_action == RESIZE_FONT))
init_lvl = 2;
InvalidateRect(hwnd, NULL, TRUE);
reset_window(init_lvl);
+ net_pending_errors();
}
break;
case IDM_COPYALL:
break;
case IDM_TEL_AYT:
back->special(TS_AYT);
+ net_pending_errors();
break;
case IDM_TEL_BRK:
back->special(TS_BRK);
+ net_pending_errors();
break;
case IDM_TEL_SYNCH:
back->special(TS_SYNCH);
+ net_pending_errors();
break;
case IDM_TEL_EC:
back->special(TS_EC);
+ net_pending_errors();
break;
case IDM_TEL_EL:
back->special(TS_EL);
+ net_pending_errors();
break;
case IDM_TEL_GA:
back->special(TS_GA);
+ net_pending_errors();
break;
case IDM_TEL_NOP:
back->special(TS_NOP);
+ net_pending_errors();
break;
case IDM_TEL_ABORT:
back->special(TS_ABORT);
+ net_pending_errors();
break;
case IDM_TEL_AO:
back->special(TS_AO);
+ net_pending_errors();
break;
case IDM_TEL_IP:
back->special(TS_IP);
+ net_pending_errors();
break;
case IDM_TEL_SUSP:
back->special(TS_SUSP);
+ net_pending_errors();
break;
case IDM_TEL_EOR:
back->special(TS_EOR);
+ net_pending_errors();
break;
case IDM_TEL_EOF:
back->special(TS_EOF);
+ net_pending_errors();
break;
case IDM_ABOUT:
showabout(hwnd);
if( lParam == 0 )
PostMessage(hwnd, WM_CHAR, ' ', 0);
break;
+ case IDM_FULLSCREEN:
+ flip_full_screen();
+ break;
default:
if (wParam >= IDM_SAVED_MIN && wParam <= IDM_SAVED_MAX) {
SendMessage(hwnd, WM_SYSCOMMAND, IDM_SAVEDSESS, wParam);
if (send_raw_mouse) {
/* send a mouse-down followed by a mouse up */
+
term_mouse(b,
MA_CLICK,
TO_CHR_X(X_POS(lParam)),
TO_CHR_Y(Y_POS(lParam)), wParam & MK_SHIFT,
- wParam & MK_CONTROL);
+ wParam & MK_CONTROL, is_alt_pressed());
term_mouse(b, MA_RELEASE, TO_CHR_X(X_POS(lParam)),
TO_CHR_Y(Y_POS(lParam)), wParam & MK_SHIFT,
- wParam & MK_CONTROL);
+ wParam & MK_CONTROL, is_alt_pressed());
} else {
/* trigger a scroll */
term_scroll(0,
case WM_RBUTTONUP:
{
int button, press;
+
switch (message) {
case WM_LBUTTONDOWN:
button = MBT_LEFT;
if (press) {
click(button,
TO_CHR_X(X_POS(lParam)), TO_CHR_Y(Y_POS(lParam)),
- wParam & MK_SHIFT, wParam & MK_CONTROL);
+ wParam & MK_SHIFT, wParam & MK_CONTROL,
+ is_alt_pressed());
SetCapture(hwnd);
} else {
term_mouse(button, MA_RELEASE,
TO_CHR_X(X_POS(lParam)),
TO_CHR_Y(Y_POS(lParam)), wParam & MK_SHIFT,
- wParam & MK_CONTROL);
+ wParam & MK_CONTROL, is_alt_pressed());
ReleaseCapture();
}
}
b = MBT_RIGHT;
term_mouse(b, MA_DRAG, TO_CHR_X(X_POS(lParam)),
TO_CHR_Y(Y_POS(lParam)), wParam & MK_SHIFT,
- wParam & MK_CONTROL);
+ wParam & MK_CONTROL, is_alt_pressed());
}
return 0;
case WM_NCMOUSEMOVE:
* 1) Keep the sizetip uptodate
* 2) Make sure the window size is _stepped_ in units of the font size.
*/
- if (!cfg.locksize && !alt_pressed) {
+ if (cfg.resize_action == RESIZE_TERM && !alt_pressed) {
int width, height, w, h, ew, eh;
LPRECT r = (LPRECT) lParam;
return rv;
}
- break;
/* break; (never reached) */
case WM_SIZE:
#ifdef RDB_DEBUG_PATCH
if (wParam == SIZE_RESTORED || wParam == SIZE_MAXIMIZED)
SetWindowText(hwnd, window_name);
- if (cfg.lockfont && cfg.locksize) {
+ if (cfg.resize_action == RESIZE_DISABLED) {
/* A resize, well it better be a minimize. */
reset_window(-1);
} else {
was_zoomed = 1;
prev_rows = rows;
prev_cols = cols;
- if (cfg.lockfont) {
+ if (cfg.resize_action != RESIZE_FONT) {
w = width / font_width;
if (w < 1) w = 1;
h = height / font_height;
reset_window(0);
} else if (wParam == SIZE_RESTORED && was_zoomed) {
was_zoomed = 0;
- if (cfg.lockfont)
+ if (cfg.resize_action != RESIZE_FONT)
term_size(prev_rows, prev_cols, cfg.savelines);
reset_window(0);
}
* down the connection during an NT opaque drag.)
*/
if (resizing) {
- if (!cfg.locksize && !alt_pressed) {
+ if (cfg.resize_action == RESIZE_TERM && !alt_pressed) {
need_backend_resize = TRUE;
w = (width-cfg.window_border*2) / font_width;
if (w < 1) w = 1;
if (len != 0) {
/*
+ * Interrupt an ongoing paste. I'm not sure
+ * this is sensible, but for the moment it's
+ * preferable to having to faff about buffering
+ * things.
+ */
+ term_nopaste();
+
+ /*
* We need not bother about stdin backlogs
* here, because in GUI PuTTY we can't do
* anything about it anyway; there's no means
* messages. We _have_ to buffer everything
* we're sent.
*/
- ldisc_send(buf, len);
+ ldisc_send(buf, len, 1);
show_mouseptr(0);
}
}
}
+ net_pending_errors();
return 0;
case WM_INPUTLANGCHANGE:
{
if (n > 0) {
buff = (char*) smalloc(n);
ImmGetCompositionStringW(hIMC, GCS_RESULTSTR, buff, n);
- luni_send((unsigned short *)buff, n / 2);
+ luni_send((unsigned short *)buff, n / 2, 1);
free(buff);
}
ImmReleaseContext(hwnd, hIMC);
buf[1] = wParam;
buf[0] = wParam >> 8;
- lpage_send(kbd_codepage, buf, 2);
+ lpage_send(kbd_codepage, buf, 2, 1);
} else {
char c = (unsigned char) wParam;
- lpage_send(kbd_codepage, &c, 1);
+ lpage_send(kbd_codepage, &c, 1, 1);
}
return (0);
case WM_CHAR:
*/
{
char c = (unsigned char)wParam;
- lpage_send(CP_ACP, &c, 1);
+ lpage_send(CP_ACP, &c, 1, 1);
}
return 0;
case WM_SETCURSOR:
seen_key_event = 1;
}
- /* Make sure we're not pasting */
- if (key_down)
- term_nopaste();
-
if (compose_state > 1 && left_alt)
compose_state = 0;
/* Okay we've done everything interesting; let windows deal with
* the boring stuff */
{
+ BOOL capsOn=0;
+
+ /* helg: clear CAPS LOCK state if caps lock switches to cyrillic */
+ if(cfg.xlat_capslockcyr && keystate[VK_CAPITAL] != 0) {
+ capsOn= !left_alt;
+ keystate[VK_CAPITAL] = 0;
+ }
+
r = ToAsciiEx(wParam, scan, keystate, keys, 0, kbd_layout);
#ifdef SHOW_TOASCII_RESULT
if (r == 1 && !key_down) {
#endif
if (r > 0) {
WCHAR keybuf;
+
+ /*
+ * Interrupt an ongoing paste. I'm not sure this is
+ * sensible, but for the moment it's preferable to
+ * having to faff about buffering things.
+ */
+ term_nopaste();
+
p = output;
for (i = 0; i < r; i++) {
unsigned char ch = (unsigned char) keys[i];
return 0;
}
keybuf = nc;
- luni_send(&keybuf, 1);
+ luni_send(&keybuf, 1, 1);
continue;
}
if (alt_sum) {
if (in_utf || dbcs_screenfont) {
keybuf = alt_sum;
- luni_send(&keybuf, 1);
+ luni_send(&keybuf, 1, 1);
} else {
ch = (char) alt_sum;
/*
* messages. We _have_ to buffer
* everything we're sent.
*/
- ldisc_send(&ch, 1);
+ ldisc_send(&ch, 1, 1);
}
alt_sum = 0;
} else
- lpage_send(kbd_codepage, &ch, 1);
+ lpage_send(kbd_codepage, &ch, 1, 1);
} else {
- static char cbuf[] = "\033 ";
- cbuf[1] = ch;
- lpage_send(kbd_codepage, cbuf + !left_alt,
- 1 + !!left_alt);
+ if(capsOn && ch < 0x80) {
+ WCHAR cbuf[2];
+ cbuf[0] = 27;
+ cbuf[1] = xlat_uskbd2cyrllic(ch);
+ luni_send(cbuf+!left_alt, 1+!!left_alt, 1);
+ } else {
+ char cbuf[2];
+ cbuf[0] = '\033';
+ cbuf[1] = ch;
+ lpage_send(kbd_codepage, cbuf+!left_alt, 1+!!left_alt, 1);
+ }
}
show_mouseptr(0);
}
*/
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);
/*
* Toggle full screen mode. Thanks to cwis@nerim.fr for the
* implementation.
+ * Revised by <wez@thebrainroom.com>
*/
static void flip_full_screen(void)
{
- if (!full_screen) {
- int cx, cy;
-
- cx = GetSystemMetrics(SM_CXSCREEN);
- cy = GetSystemMetrics(SM_CYSCREEN);
- GetWindowPlacement(hwnd, &old_wind_placement);
- old_wind_style = GetWindowLong(hwnd, GWL_STYLE);
- SetWindowLong(hwnd, GWL_STYLE,
- old_wind_style & ~(WS_CAPTION | WS_BORDER | WS_THICKFRAME));
- SetWindowPos(hwnd, HWND_TOP, 0, 0, cx, cy, SWP_SHOWWINDOW);
- full_screen = 1;
+ WINDOWPLACEMENT wp;
+ LONG style;
+
+ wp.length = sizeof(wp);
+ GetWindowPlacement(hwnd, &wp);
+
+ full_screen = !full_screen;
+
+ if (full_screen) {
+ 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);
+
+ wp.showCmd = SW_SHOWMAXIMIZED;
+ SetWindowPlacement(hwnd, &wp);
} else {
- SetWindowLong(hwnd, GWL_STYLE, old_wind_style);
- SetWindowPlacement(hwnd,&old_wind_placement);
- full_screen = 0;
+ 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);
}