/*
* TODO - GetMousePos(POINT * result) from ntconio.c
* TODO - implement nodelay
+ * TODO - improve screen-repainting performance, using implied wraparound to reduce write's
+ * TODO - make it optional whether screen is restored or not when non-buffered
*/
#include <curses.priv.h>
+
+#ifdef __MINGW32__
#include <tchar.h>
+#else
+#include <windows.h>
+#include <wchar.h>
+#endif
+
#include <io.h>
#define PSAPI_VERSION 2
#define CUR my_term.type.
-MODULE_ID("$Id: win_driver.c,v 1.39 2014/06/29 22:48:17 tom Exp $")
+MODULE_ID("$Id: win_driver.c,v 1.52 2014/10/25 00:24:24 tom Exp $")
#ifndef __GNUC__
# error We need GCC to compile for MinGW
#define AdjustY() (CON.buffered ? 0 : (int) CON.SBI.srWindow.Top)
+#if USE_WIDEC_SUPPORT
+#define write_screen WriteConsoleOutputW
+#define read_screen ReadConsoleOutputW
+#else
+#define write_screen WriteConsoleOutput
+#define read_screen ReadConsoleOutput
+#endif
+
static const LONG keylist[] =
{
GenMap(VK_PRIOR, KEY_PPAGE),
WORD pairs[NUMPAIRS];
COORD origin;
CHAR_INFO *save_screen;
+ COORD save_size;
+ SMALL_RECT save_region;
CONSOLE_SCREEN_BUFFER_INFO SBI;
+ CONSOLE_SCREEN_BUFFER_INFO save_SBI;
+ CONSOLE_CURSOR_INFO save_CI;
} CON;
static BOOL console_initialized = FALSE;
return (WORD) a;
}
+#define RevAttr(attr) \
+ (WORD) (((attr) & 0xff00) | \
+ ((((attr) & 0x07) << 4) | \
+ (((attr) & 0x70) >> 4)))
+
static WORD
MapAttr(WORD res, attr_t ch)
{
}
if (ch & A_REVERSE) {
- res = (WORD) ((res & 0xff00) |
- (((res & 0x07) << 4) |
- ((res & 0x70) >> 4)));
+ res = RevAttr(res);
}
if (ch & A_STANDOUT) {
- res = (WORD) ((res & 0xff00) |
- (((res & 0x07) << 4) |
- ((res & 0x70) >> 4)) |
- BACKGROUND_INTENSITY);
+ res = RevAttr(res) | BACKGROUND_INTENSITY;
}
if (ch & A_BOLD)
return res;
}
+#if 0 /* def TRACE */
+static void
+dump_screen(const char *fn, int ln)
+{
+ int max_cells = (CON.SBI.dwSize.Y * (1 + CON.SBI.dwSize.X)) + 1;
+ char output[max_cells];
+ CHAR_INFO save_screen[max_cells];
+ COORD save_size;
+ SMALL_RECT save_region;
+ COORD bufferCoord;
+
+ T(("dump_screen %s@%d", fn, ln));
+
+ save_region.Top = CON.SBI.srWindow.Top;
+ save_region.Left = CON.SBI.srWindow.Left;
+ save_region.Bottom = CON.SBI.srWindow.Bottom;
+ save_region.Right = CON.SBI.srWindow.Right;
+
+ save_size.X = (SHORT) (save_region.Right - save_region.Left + 1);
+ save_size.Y = (SHORT) (save_region.Bottom - save_region.Top + 1);
+
+ bufferCoord.X = bufferCoord.Y = 0;
+
+ if (read_screen(CON.hdl,
+ save_screen,
+ save_size,
+ bufferCoord,
+ &save_region)) {
+ int i, j;
+ int ij = 0;
+ int k = 0;
+
+ for (i = save_region.Top; i <= save_region.Bottom; ++i) {
+ for (j = save_region.Left; j <= save_region.Right; ++j) {
+ output[k++] = save_screen[ij++].Char.AsciiChar;
+ }
+ output[k++] = '\n';
+ }
+ output[k] = 0;
+
+ T(("DUMP: %d,%d - %d,%d",
+ save_region.Top,
+ save_region.Left,
+ save_region.Bottom,
+ save_region.Right));
+ T(("%s", output));
+ }
+}
+
+#else
+#define dump_screen(fn,ln) /* nothing */
+#endif
+
#if USE_WIDEC_SUPPORT
/*
* TODO: support surrogate pairs
* TODO: support combining characters
* TODO: support acsc
- * TODO: check wcwidth of base character, fill if needed for double-width
* TODO: _nc_wacs should be part of sp.
*/
static BOOL
++actual;
}
- loc.X = (short) 0;
- loc.Y = (short) 0;
- siz.X = (short) actual;
+ loc.X = (SHORT) 0;
+ loc.Y = (SHORT) 0;
+ siz.X = (SHORT) actual;
siz.Y = 1;
- rec.Left = (short) x;
+ rec.Left = (SHORT) x;
rec.Top = (SHORT) (y + AdjustY());
- rec.Right = (short) (x + limit - 1);
+ rec.Right = (SHORT) (x + limit - 1);
rec.Bottom = rec.Top;
- return WriteConsoleOutputW(CON.hdl, ci, siz, loc, &rec);
+ return write_screen(CON.hdl, ci, siz, loc, &rec);
}
#define con_write(tcb, y, x, str, n) con_write16(tcb, y, x, str, n)
#else
rec.Right = (short) (x + n - 1);
rec.Bottom = rec.Top;
- return WriteConsoleOutput(CON.hdl, ci, siz, loc, &rec);
+ return write_screen(CON.hdl, ci, siz, loc, &rec);
}
#define con_write(tcb, y, x, str, n) con_write8(tcb, y, x, str, n)
#endif
restore_original_screen(void)
{
COORD bufferCoord;
- SMALL_RECT writeRegion;
bool result = FALSE;
+ SMALL_RECT save_region = CON.save_region;
- if (CON.window_only) {
- writeRegion.Top = CON.SBI.srWindow.Top;
- writeRegion.Left = CON.SBI.srWindow.Left;
- writeRegion.Bottom = CON.SBI.srWindow.Bottom;
- writeRegion.Right = CON.SBI.srWindow.Right;
- T(("... restoring window"));
- } else {
- writeRegion.Top = 0;
- writeRegion.Left = 0;
- writeRegion.Bottom = (SHORT) (CON.SBI.dwSize.Y - 1);
- writeRegion.Right = (SHORT) (CON.SBI.dwSize.X - 1);
- T(("... restoring entire buffer"));
- }
+ T(("... restoring %s", CON.window_only ? "window" : "entire buffer"));
- bufferCoord.X = bufferCoord.Y = 0;
+ bufferCoord.X = (SHORT) (CON.window_only ? CON.SBI.srWindow.Left : 0);
+ bufferCoord.Y = (SHORT) (CON.window_only ? CON.SBI.srWindow.Top : 0);
- if (WriteConsoleOutput(CON.hdl,
- CON.save_screen,
- CON.SBI.dwSize,
- bufferCoord,
- &writeRegion)) {
+ if (write_screen(CON.hdl,
+ CON.save_screen,
+ CON.save_size,
+ bufferCoord,
+ &save_region)) {
result = TRUE;
mvcur(-1, -1, LINES - 2, 0);
+ T(("... restore original screen contents ok %dx%d (%d,%d - %d,%d)",
+ CON.save_size.Y,
+ CON.save_size.X,
+ save_region.Top,
+ save_region.Left,
+ save_region.Bottom,
+ save_region.Right));
+ } else {
+ T(("... restore original screen contents err"));
}
- T(("... restore original screen contents %s", result ? "ok" : "err"));
return result;
}
Height = screen_lines(sp);
nonempty = min(Height, NewScreen(sp)->_maxy + 1);
+ T(("... %dx%d clear cur:%d new:%d",
+ Height, Width,
+ CurScreen(sp)->_clear,
+ NewScreen(sp)->_clear));
+
+ if (SP_PARM->_endwin) {
+
+ T(("coming back from shell mode"));
+ NCURSES_SP_NAME(reset_prog_mode) (NCURSES_SP_ARG);
+
+ NCURSES_SP_NAME(_nc_mvcur_resume) (NCURSES_SP_ARG);
+ NCURSES_SP_NAME(_nc_screen_resume) (NCURSES_SP_ARG);
+ SP_PARM->_mouse_resume(SP_PARM);
+
+ SP_PARM->_endwin = FALSE;
+ }
+
if ((CurScreen(sp)->_clear || NewScreen(sp)->_clear)) {
int x;
#if USE_WIDEC_SUPPORT
CurScreen(sp)->_clear = FALSE;
NewScreen(sp)->_clear = FALSE;
touchwin(NewScreen(sp));
+ T(("... cleared %dx%d lines @%d of screen", nonempty, Width,
+ AdjustY()));
}
for (y = 0; y < nonempty; y++) {
static int
wcon_dobeepflash(TERMINAL_CONTROL_BLOCK * TCB,
- int beepFlag GCC_UNUSED)
+ int beepFlag)
{
SCREEN *sp;
- int res = ERR;
+ int res = OK;
+
+ int high = (CON.SBI.srWindow.Bottom - CON.SBI.srWindow.Top + 1);
+ int wide = (CON.SBI.srWindow.Right - CON.SBI.srWindow.Left + 1);
+ int max_cells = (high * wide);
+ int i;
+
+ CHAR_INFO this_screen[max_cells];
+ CHAR_INFO that_screen[max_cells];
+ COORD this_size;
+ SMALL_RECT this_region;
+ COORD bufferCoord;
AssertTCB();
+
SetSP();
+ this_region.Top = CON.SBI.srWindow.Top;
+ this_region.Left = CON.SBI.srWindow.Left;
+ this_region.Bottom = CON.SBI.srWindow.Bottom;
+ this_region.Right = CON.SBI.srWindow.Right;
+
+ this_size.X = (SHORT) wide;
+ this_size.Y = (SHORT) high;
+
+ bufferCoord.X = this_region.Left;
+ bufferCoord.Y = this_region.Top;
+
+ if (!beepFlag &&
+ read_screen(CON.hdl,
+ this_screen,
+ this_size,
+ bufferCoord,
+ &this_region)) {
+
+ memcpy(that_screen, this_screen, sizeof(that_screen));
+
+ for (i = 0; i < max_cells; i++) {
+ that_screen[i].Attributes = RevAttr(that_screen[i].Attributes);
+ }
+
+ write_screen(CON.hdl, that_screen, this_size, bufferCoord, &this_region);
+ Sleep(200);
+ write_screen(CON.hdl, this_screen, this_size, bufferCoord, &this_region);
+
+ } else {
+ MessageBeep(MB_ICONWARNING); /* MB_OK might be better */
+ }
return res;
}
return OK;
}
+#define MIN_WIDE 80
+#define MIN_HIGH 24
+
+/*
+ * In "normal" mode, reset the buffer- and window-sizes back to their original values.
+ */
+static void
+set_scrollback(bool normal, CONSOLE_SCREEN_BUFFER_INFO * info)
+{
+ SMALL_RECT rect;
+ COORD coord;
+ bool changed = FALSE;
+
+ T((T_CALLED("win32con::set_scrollback(%s)"),
+ (normal
+ ? "normal"
+ : "application")));
+
+ T(("... SBI.srWindow %d,%d .. %d,%d",
+ info->srWindow.Top,
+ info->srWindow.Left,
+ info->srWindow.Bottom,
+ info->srWindow.Right));
+ T(("... SBI.dwSize %dx%d",
+ info->dwSize.Y,
+ info->dwSize.X));
+
+ if (normal) {
+ rect = info->srWindow;
+ coord = info->dwSize;
+ if (memcmp(info, &CON.SBI, sizeof(*info)) != 0) {
+ changed = TRUE;
+ CON.SBI = *info;
+ }
+ } else {
+ int high = info->srWindow.Bottom - info->srWindow.Top + 1;
+ int wide = info->srWindow.Right - info->srWindow.Left + 1;
+
+ if (high < MIN_HIGH) {
+ T(("... height %d < %d", high, MIN_HIGH));
+ high = MIN_HIGH;
+ changed = TRUE;
+ }
+ if (wide < MIN_WIDE) {
+ T(("... width %d < %d", wide, MIN_WIDE));
+ wide = MIN_WIDE;
+ changed = TRUE;
+ }
+
+ rect.Left =
+ rect.Top = 0;
+ rect.Right = (SHORT) (wide - 1);
+ rect.Bottom = (SHORT) (high - 1);
+
+ coord.X = (SHORT) wide;
+ coord.Y = (SHORT) high;
+
+ if (info->dwSize.Y != high ||
+ info->dwSize.X != wide ||
+ info->srWindow.Top != 0 ||
+ info->srWindow.Left != 0) {
+ changed = TRUE;
+ }
+
+ }
+
+ if (changed) {
+ T(("... coord %d,%d", coord.Y, coord.X));
+ T(("... rect %d,%d - %d,%d",
+ rect.Top, rect.Left,
+ rect.Bottom, rect.Right));
+ SetConsoleScreenBufferSize(CON.hdl, coord); /* dwSize */
+ SetConsoleWindowInfo(CON.hdl, TRUE, &rect); /* srWindow */
+ get_SBI();
+ }
+ returnVoid;
+}
+
static int
wcon_mode(TERMINAL_CONTROL_BLOCK * TCB, int progFlag, int defFlag)
{
if (sp->_keypad_on)
_nc_keypad(sp, TRUE);
}
+ if (!CON.buffered) {
+ set_scrollback(FALSE, &CON.SBI);
+ }
code = OK;
}
}
+ T(("... buffered:%d, clear:%d", CON.buffered, CurScreen(sp)->_clear));
} else { /* shell mode */
if (defFlag) {
/* def_shell_mode */
}
code = wcon_sgmode(TCB, TRUE, &(_term->Ottyb));
if (!CON.buffered) {
+ set_scrollback(TRUE, &CON.save_SBI);
if (!restore_original_screen())
code = ERR;
}
+ SetConsoleCursorInfo(CON.hdl, &CON.save_CI);
}
}
- return (code);
+ returnCode(code);
}
static void
returnVoid;
}
-/*
- * Attempt to save the screen contents. PDCurses does this if
- * PDC_RESTORE_SCREEN is set, giving the same visual appearance on restoration
- * as if the library had allocated a console buffer.
- */
static bool
-save_original_screen(void)
+read_screen_data(void)
{
bool result = FALSE;
- COORD bufferSize;
COORD bufferCoord;
- SMALL_RECT readRegion;
size_t want;
- bufferSize.X = CON.SBI.dwSize.X;
- bufferSize.Y = CON.SBI.dwSize.Y;
- want = (size_t) (bufferSize.X * bufferSize.Y);
+ CON.save_size.X = (SHORT) (CON.save_region.Right
+ - CON.save_region.Left + 1);
+ CON.save_size.Y = (SHORT) (CON.save_region.Bottom
+ - CON.save_region.Top + 1);
+
+ want = (size_t) (CON.save_size.X * CON.save_size.Y);
if ((CON.save_screen = malloc(want * sizeof(CHAR_INFO))) != 0) {
- bufferCoord.X = bufferCoord.Y = 0;
-
- readRegion.Top = 0;
- readRegion.Left = 0;
- readRegion.Bottom = (SHORT) (bufferSize.Y - 1);
- readRegion.Right = (SHORT) (bufferSize.X - 1);
-
- T(("... reading console buffer %dx%d into %d,%d - %d,%d at %d,%d",
- bufferSize.Y, bufferSize.X,
- readRegion.Top,
- readRegion.Left,
- readRegion.Bottom,
- readRegion.Right,
+ bufferCoord.X = (SHORT) (CON.window_only ? CON.SBI.srWindow.Left : 0);
+ bufferCoord.Y = (SHORT) (CON.window_only ? CON.SBI.srWindow.Top : 0);
+
+ T(("... reading console %s %dx%d into %d,%d - %d,%d at %d,%d",
+ CON.window_only ? "window" : "buffer",
+ CON.save_size.Y, CON.save_size.X,
+ CON.save_region.Top,
+ CON.save_region.Left,
+ CON.save_region.Bottom,
+ CON.save_region.Right,
bufferCoord.Y,
bufferCoord.X));
- if (ReadConsoleOutput(CON.hdl,
- CON.save_screen,
- bufferSize,
- bufferCoord,
- &readRegion)) {
+ if (read_screen(CON.hdl,
+ CON.save_screen,
+ CON.save_size,
+ bufferCoord,
+ &CON.save_region)) {
result = TRUE;
} else {
T((" error %#lx", (unsigned long) GetLastError()));
FreeAndNull(CON.save_screen);
+ }
+ }
- bufferSize.X = (SHORT) (CON.SBI.srWindow.Right
- - CON.SBI.srWindow.Left + 1);
- bufferSize.Y = (SHORT) (CON.SBI.srWindow.Bottom
- - CON.SBI.srWindow.Top + 1);
- want = (size_t) (bufferSize.X * bufferSize.Y);
-
- if ((CON.save_screen = malloc(want * sizeof(CHAR_INFO))) != 0) {
- bufferCoord.X = bufferCoord.Y = 0;
-
- readRegion.Top = CON.SBI.srWindow.Top;
- readRegion.Left = CON.SBI.srWindow.Left;
- readRegion.Bottom = CON.SBI.srWindow.Bottom;
- readRegion.Right = CON.SBI.srWindow.Right;
-
- T(("... reading console window %dx%d into %d,%d - %d,%d at %d,%d",
- bufferSize.Y, bufferSize.X,
- readRegion.Top,
- readRegion.Left,
- readRegion.Bottom,
- readRegion.Right,
- bufferCoord.Y,
- bufferCoord.X));
-
- if (ReadConsoleOutput(CON.hdl,
- CON.save_screen,
- bufferSize,
- bufferCoord,
- &readRegion)) {
- result = TRUE;
- CON.window_only = TRUE;
- } else {
- T((" error %#lx", (unsigned long) GetLastError()));
- }
- }
+ return result;
+}
+
+/*
+ * Attempt to save the screen contents. PDCurses does this if
+ * PDC_RESTORE_SCREEN is set, giving the same visual appearance on
+ * restoration as if the library had allocated a console buffer. MSDN
+ * says that the data which can be read is limited to 64Kb (and may be
+ * less).
+ */
+static bool
+save_original_screen(void)
+{
+ bool result = FALSE;
+
+ CON.save_region.Top = 0;
+ CON.save_region.Left = 0;
+ CON.save_region.Bottom = (SHORT) (CON.SBI.dwSize.Y - 1);
+ CON.save_region.Right = (SHORT) (CON.SBI.dwSize.X - 1);
+
+ if (read_screen_data()) {
+ result = TRUE;
+ } else {
+
+ CON.save_region.Top = CON.SBI.srWindow.Top;
+ CON.save_region.Left = CON.SBI.srWindow.Left;
+ CON.save_region.Bottom = CON.SBI.srWindow.Bottom;
+ CON.save_region.Right = CON.SBI.srWindow.Right;
+
+ CON.window_only = TRUE;
+
+ if (read_screen_data()) {
+ result = TRUE;
}
}
static int
Adjust(int milliseconds, int diff)
{
- if (milliseconds == INFINITY)
- return milliseconds;
- milliseconds -= diff;
- if (milliseconds < 0)
- milliseconds = 0;
+ if (milliseconds != INFINITY) {
+ milliseconds -= diff;
+ if (milliseconds < 0)
+ milliseconds = 0;
+ }
return milliseconds;
}
diff = (int) tdiff(fstart, fend);
milliseconds = Adjust(milliseconds, diff);
- if (!isImmed && milliseconds == 0)
+ if (!isImmed && milliseconds <= 0)
break;
if (rc == WAIT_OBJECT_0) {
goto end;
}
continue;
+ /* e.g., FOCUS_EVENT */
default:
+ CONSUME();
selectActiveHandle();
continue;
}
returnCode(OK);
}
+static int
+wcon_cursorSet(TERMINAL_CONTROL_BLOCK * TCB GCC_UNUSED, int mode)
+{
+ int res = -1;
+ CONSOLE_CURSOR_INFO this_CI = CON.save_CI;
+ T((T_CALLED("win32con:wcon_cursorSet(%d)"), mode));
+ switch (mode) {
+ case 0:
+ this_CI.bVisible = FALSE;
+ break;
+ case 1:
+ break;
+ case 2:
+ this_CI.dwSize = 100;
+ break;
+ }
+ SetConsoleCursorInfo(CON.hdl, &this_CI);
+ returnCode(res);
+}
+
static bool
wcon_kyExist(TERMINAL_CONTROL_BLOCK * TCB GCC_UNUSED, int keycode)
{
wcon_nap, /* nap */
wcon_kpad, /* kpad */
wcon_keyok, /* kyOk */
- wcon_kyExist /* kyExist */
+ wcon_kyExist, /* kyExist */
+ wcon_cursorSet /* cursorSet */
};
/* --------------------------------------------------------- */
#endif
/* Borrowed from ansicon project.
- Check wether or not a I/O handle is associated with
+ Check whether or not an I/O handle is associated with
a Windows console.
*/
static BOOL
IsConsoleHandle(HANDLE hdl)
{
DWORD dwFlag = 0;
+ BOOL result;
+
if (!GetConsoleMode(hdl, &dwFlag)) {
- return (int) WriteConsoleA(hdl, NULL, 0, &dwFlag, NULL);
+ result = (int) WriteConsoleA(hdl, NULL, 0, &dwFlag, NULL);
+ } else {
+ result = (int) (dwFlag & ENABLE_PROCESSED_OUTPUT);
}
- return (int) (dwFlag & ENABLE_PROCESSED_OUTPUT);
+ return result;
}
/* Our replacement for the systems _isatty to include also
int
_nc_mingw_isatty(int fd)
{
- if (_isatty(fd))
- return 1;
-#if WINVER < 0x0600
- return 0;
+ int result = 0;
+
+#ifdef __MING32__
+#define SysISATTY(fd) _isatty(fd)
#else
- return _ismintty(fd, NULL);
+#define SysISATTY(fd) isatty(fd)
#endif
+ if (SysISATTY(fd)) {
+ result = 1;
+ } else {
+#if WINVER >= 0x0600
+ result = _ismintty(fd, NULL);
+#endif
+ }
+ return result;
}
/* This is used when running in terminfo mode to discover,
SCREEN *sp; \
TERMINAL *term = 0; \
int code = ERR; \
- if (_nc_screen_chain==0) \
- return 0; \
+ if (_nc_screen_chain == 0) \
+ return 0; \
for (each_screen(sp)) { \
- if (sp->_term && sp->_term->Filedes==fd) { \
- term = sp->_term; \
- break; \
+ if (sp->_term && (sp->_term->Filedes == fd)) { \
+ term = sp->_term; \
+ break; \
} \
} \
- assert(term!=0)
+ assert(term != 0)
int
_nc_mingw_tcsetattr(
BOOL buffered = TRUE;
BOOL b;
+ START_TRACE();
if (_nc_mingw_isatty(0)) {
CON.isMinTTY = TRUE;
}
b = AttachConsole(ATTACH_PARENT_PROCESS);
if (getenv("NCGDB") || getenv("NCURSES_CONSOLE2")) {
- CON.hdl = CON.out;
+ T(("... will not buffer console"));
buffered = FALSE;
+ CON.hdl = CON.out;
} else {
+ T(("... creating console buffer"));
CON.hdl = CreateConsoleScreenBuffer(GENERIC_READ | GENERIC_WRITE,
0,
NULL,
if (CON.hdl != INVALID_HANDLE_VALUE) {
CON.buffered = buffered;
get_SBI();
+ CON.save_SBI = CON.SBI;
if (!buffered) {
save_original_screen();
+ set_scrollback(FALSE, &CON.SBI);
}
+ GetConsoleCursorInfo(CON.hdl, &CON.save_CI);
+ T(("... initial cursor is %svisible, %d%%",
+ (CON.save_CI.bVisible ? "" : "not-"),
+ (int) CON.save_CI.dwSize));
}
console_initialized = TRUE;
projects / ncurses.git / blobdiff