lukechilds
/
node
mirror of https://github.com/lukechilds/node.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

Windows: watcher for tty events

v0.7.4-release
Bert Belder 14 years ago
committed by Ryan Dahl
parent
4f8dd28f7e
commit
b0eed65584
1 changed files with 354 additions and 0 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 354
      src/node_stdio_win32.cc

354
src/node_stdio_win32.cc
View File

@ -16,6 +16,109 @@ namespace node {
#define THROW_BAD_ARGS \ #define THROW_BAD_ARGS \
return ThrowException(Exception::TypeError(String::New("Bad argument"))); return ThrowException(Exception::TypeError(String::New("Bad argument")));
#define KEY(scancode, name) \
scancodes[scancode] = name;
#define MAX_KEY VK_RMENU
static const char* scancodes[MAX_KEY + 1] = {0};
static Persistent<String> name_symbol;
static Persistent<String> shift_symbol;
static Persistent<String> ctrl_symbol;
static Persistent<String> meta_symbol;
static void init_scancode_table() {
KEY(VK_CANCEL, "break")
KEY(VK_BACK, "backspace")
KEY(VK_TAB, "tab")
KEY(VK_CLEAR, "clear")
KEY(VK_RETURN, "enter")
KEY(VK_PAUSE, "pause")
KEY(VK_ESCAPE, "escape")
KEY(VK_SPACE, "space")
KEY(VK_PRIOR, "pageup")
KEY(VK_NEXT, "pagedown")
KEY(VK_END, "end")
KEY(VK_HOME, "home")
KEY(VK_LEFT, "left")
KEY(VK_UP, "up")
KEY(VK_RIGHT, "right")
KEY(VK_DOWN, "down")
KEY(VK_SELECT, "select")
KEY(VK_PRINT, "print")
KEY(VK_EXECUTE, "execute")
KEY(VK_SNAPSHOT, "printscreen")
KEY(VK_INSERT, "insert")
KEY(VK_DELETE, "delete")
KEY(VK_HELP, "help")
KEY(VK_LWIN, "lwin")
KEY(VK_RWIN, "rwin")
KEY(VK_APPS, "apps")
KEY(VK_SLEEP, "sleep")
KEY(VK_NUMPAD0, "numpad0")
KEY(VK_NUMPAD1, "numpad1")
KEY(VK_NUMPAD2, "numpad2")
KEY(VK_NUMPAD3, "numpad3")
KEY(VK_NUMPAD4, "numpad4")
KEY(VK_NUMPAD5, "numpad5")
KEY(VK_NUMPAD6, "numpad6")
KEY(VK_NUMPAD7, "numpad7")
KEY(VK_NUMPAD8, "numpad8")
KEY(VK_NUMPAD9, "numpad9")
KEY(VK_MULTIPLY, "numpad*")
KEY(VK_ADD, "numpad+")
KEY(VK_SEPARATOR, "numpad,")
KEY(VK_SUBTRACT, "numpad-")
KEY(VK_DECIMAL, "numpad.")
KEY(VK_DIVIDE, "numpad/")
KEY(VK_F1, "f1")
KEY(VK_F2, "f2")
KEY(VK_F3, "f3")
KEY(VK_F4, "f4")
KEY(VK_F5, "f5")
KEY(VK_F6, "f6")
KEY(VK_F7, "f7")
KEY(VK_F8, "f8")
KEY(VK_F9, "f9")
KEY(VK_F10, "f10")
KEY(VK_F11, "f11")
KEY(VK_F12, "f12")
KEY(VK_F13, "f13")
KEY(VK_F14, "f14")
KEY(VK_F15, "f15")
KEY(VK_F16, "f16")
KEY(VK_F17, "f17")
KEY(VK_F18, "f18")
KEY(VK_F19, "f19")
KEY(VK_F20, "f20")
KEY(VK_F21, "f21")
KEY(VK_F22, "f22")
KEY(VK_F23, "f23")
KEY(VK_F24, "f24")
KEY(VK_OEM_PLUS, "+")
KEY(VK_OEM_MINUS, "-")
KEY(VK_OEM_COMMA, ",")
KEY(VK_OEM_PERIOD, ".")
// Letter keys have the ascii code of their uppercase equivalent as a scan code
for (int i = 0; i < 26; i++) {
char *name = new char[2];
name[0] = 'a' + i;
name[1] = '\0';
KEY('A' + i, name)
}
// Number keys have their ascii code as scan code
for (int i = '0'; i <= '9'; i++) {
char *name = new char[2];
name[0] = i;
name[1] = '\0';
KEY(i, name)
}
}
/* /*
* Flush stdout and stderr on node exit * Flush stdout and stderr on node exit
* Not necessary on windows, so a no-op * Not necessary on windows, so a no-op
@ -142,7 +245,254 @@ static Handle<Value> GetWindowSize (const Arguments& args) {
} }
/* TTY watcher data */
bool tty_watcher_initialized = false;
HANDLE tty_handle;
HANDLE tty_wait_handle;
void *tty_error_callback;
void *tty_keypress_callback;
void *tty_resize_callback;
static ev_async tty_avail_notifier;
static void CALLBACK tty_want_poll(void *context, BOOLEAN didTimeout) {
assert(!didTimeout);
ev_async_send(EV_DEFAULT_UC_ &tty_avail_notifier);
}
static void tty_watcher_arm() {
// Register a new wait handle before dropping the old one, because
// otherwise windows might destroy and recreate the wait thread.
// MSDN promises that thread pool threads are kept alive when they're idle,
// but apparently this does not apply to wait threads. Sigh.
HANDLE old_wait_handle = tty_wait_handle;
tty_wait_handle = NULL;
if (ev_is_active(&tty_avail_notifier)) {
if (!RegisterWaitForSingleObject(&tty_wait_handle, tty_handle, tty_want_poll, NULL,
INFINITE, WT_EXECUTEINWAITTHREAD | WT_EXECUTEONLYONCE))
ThrowException(ErrnoException(GetLastError(), "RegisterWaitForSingleObject"));
}
if (old_wait_handle != NULL) {
if (!UnregisterWait(old_wait_handle) && GetLastError() != ERROR_IO_PENDING)
ThrowException(ErrnoException(GetLastError(), "UnregisterWait"));
}
}
static void tty_watcher_disarm() {
DWORD result;
if (tty_wait_handle != NULL) {
result = UnregisterWait(tty_wait_handle);
tty_wait_handle = NULL;
if (!result && GetLastError() != ERROR_IO_PENDING)
ThrowException(ErrnoException(GetLastError(), "UnregisterWait"));
}
}
static void tty_watcher_start() {
if (!ev_is_active(&tty_avail_notifier)) {
ev_async_start(EV_DEFAULT_UC_ &tty_avail_notifier);
tty_watcher_arm();
}
}
static void tty_watcher_stop() {
if (ev_is_active(&tty_avail_notifier)) {
tty_watcher_disarm();
ev_async_stop(EV_DEFAULT_UC_ &tty_avail_notifier);
}
}
static inline void tty_emit_error(Handle<Value> err) {
HandleScope scope;
Handle<Object> global = v8::Context::GetCurrent()->Global();
Handle<Function> *handler = cb_unwrap(tty_error_callback);
Handle<Value> argv[1] = { err };
(*handler)->Call(global, 1, argv);
}
static void tty_poll(EV_P_ ev_async *watcher, int revents) {
assert(watcher == &tty_avail_notifier);
assert(revents == EV_ASYNC);
HandleScope scope;
TryCatch try_catch;
Handle<Object> global = v8::Context::GetCurrent()->Global();
Handle<Function> *callback;
INPUT_RECORD input;
KEY_EVENT_RECORD k;
const char *keyName;
DWORD i, j, numev, read;
Handle<Value> argv[2];
Handle<Object> key;
if (!GetNumberOfConsoleInputEvents(tty_handle, &numev)) {
tty_emit_error(ErrnoException(GetLastError(),
"GetNumberOfConsoleInputEvents"));
numev = 0;
}
for (i = numev; i > 0 &&
ev_is_active(EV_DEFAULT_UC_ &tty_avail_notifier); i--) {
if (!ReadConsoleInputW(tty_handle, &input, 1, &read)) {
tty_emit_error(ErrnoException(GetLastError(), "ReadConsoleInputW"));
break;
}
switch (input.EventType) {
case KEY_EVENT:
// Skip if no callback set
if (!tty_keypress_callback)
break;
k = input.Event.KeyEvent;
// Ignore keyup
if (!k.bKeyDown)
break;
// Try to find a symbolic name for the key
keyName = (k.wVirtualKeyCode <= MAX_KEY)
? scancodes[k.wVirtualKeyCode]
: 0;
// The key must have a symbolic name or a char or both
if (k.uChar.UnicodeChar == 0 && keyName == 0)
break;
// Set the event name and character
argv[0] = k.uChar.UnicodeChar
? String::New(reinterpret_cast<uint16_t*>(&k.uChar.UnicodeChar), 1)
: Undefined();
// Set the key info, if any
if (keyName) {
key = Object::New();
key->Set(name_symbol, String::New(keyName));
key->Set(shift_symbol, Boolean::New(k.dwControlKeyState &
SHIFT_PRESSED));
key->Set(ctrl_symbol, Boolean::New(k.dwControlKeyState &
(LEFT_CTRL_PRESSED | RIGHT_CTRL_PRESSED)));
key->Set(meta_symbol, Boolean::New(k.dwControlKeyState &
(LEFT_ALT_PRESSED | RIGHT_ALT_PRESSED)));
argv[1] = key;
} else {
argv[1] = Undefined();
}
callback = cb_unwrap(tty_keypress_callback);
j = k.wRepeatCount;
do {
(*callback)->Call(global, 2, argv);
} while (--j > 0 && ev_is_active(EV_DEFAULT_UC_ &tty_avail_notifier));
break;
case WINDOW_BUFFER_SIZE_EVENT:
if (!tty_resize_callback)
break;
argv[0] = Integer::New(input.Event.WindowBufferSizeEvent.dwSize.Y);
argv[1] = Integer::New(input.Event.WindowBufferSizeEvent.dwSize.X);
callback = cb_unwrap(tty_resize_callback);
(*callback)->Call(global, 2, argv);
break;
}
}
// Rearm the watcher
tty_watcher_arm();
// Emit fatal errors and unhandled error events
if (try_catch.HasCaught()) {
FatalException(try_catch);
}
}
/* StartTTYWatcher(fd, onError, onKeypress, onResize) */
static Handle<Value> InitTTYWatcher(const Arguments& args) {
HandleScope scope;
if (tty_watcher_initialized)
THROW_ERROR("TTY watcher already initialized")
if (!args[0]->IsNumber())
THROW_BAD_ARGS;
tty_handle = (HANDLE)_get_osfhandle(args[0]->IntegerValue());
if (!args[1]->IsFunction())
THROW_BAD_ARGS;
tty_error_callback = cb_persist(args[1]);
tty_keypress_callback = args[2]->IsFunction()
? cb_persist(args[2])
: NULL;
tty_resize_callback = args[3]->IsFunction()
? cb_persist(args[3])
: NULL;
ev_async_init(EV_DEFAULT_UC_ &tty_avail_notifier, tty_poll);
tty_watcher_initialized = true;
tty_wait_handle = NULL;
return Undefined();
}
static Handle<Value> DestroyTTYWatcher(const Arguments& args) {
if (!tty_watcher_initialized)
THROW_ERROR("TTY watcher not initialized")
tty_watcher_stop();
if (tty_error_callback != NULL)
cb_destroy(cb_unwrap(tty_error_callback));
if (tty_keypress_callback != NULL)
cb_destroy(cb_unwrap(tty_keypress_callback));
if (tty_resize_callback != NULL)
cb_destroy(cb_unwrap(tty_resize_callback));
tty_watcher_initialized = false;
return Undefined();
}
static Handle<Value> StartTTYWatcher(const Arguments& args) {
if (!tty_watcher_initialized)
THROW_ERROR("TTY watcher not initialized")
tty_watcher_start();
return Undefined();
}
static Handle<Value> StopTTYWatcher(const Arguments& args) {
if (!tty_watcher_initialized)
THROW_ERROR("TTY watcher not initialized")
tty_watcher_stop();
return Undefined();
}
void Stdio::Initialize(v8::Handle<v8::Object> target) { void Stdio::Initialize(v8::Handle<v8::Object> target) {
init_scancode_table();
name_symbol = NODE_PSYMBOL("name");
shift_symbol = NODE_PSYMBOL("shift");
ctrl_symbol = NODE_PSYMBOL("ctrl");
meta_symbol = NODE_PSYMBOL("meta");
target->Set(String::NewSymbol("stdoutFD"), Integer::New(STDOUT_FILENO)); target->Set(String::NewSymbol("stdoutFD"), Integer::New(STDOUT_FILENO));
target->Set(String::NewSymbol("stderrFD"), Integer::New(STDERR_FILENO)); target->Set(String::NewSymbol("stderrFD"), Integer::New(STDERR_FILENO));
target->Set(String::NewSymbol("stdinFD"), Integer::New(STDIN_FILENO)); target->Set(String::NewSymbol("stdinFD"), Integer::New(STDIN_FILENO));
@ -154,6 +504,10 @@ void Stdio::Initialize(v8::Handle<v8::Object> target) {
NODE_SET_METHOD(target, "setRawMode", SetRawMode); NODE_SET_METHOD(target, "setRawMode", SetRawMode);
NODE_SET_METHOD(target, "openStdin", OpenStdin); NODE_SET_METHOD(target, "openStdin", OpenStdin);
NODE_SET_METHOD(target, "getWindowSize", GetWindowSize); NODE_SET_METHOD(target, "getWindowSize", GetWindowSize);
NODE_SET_METHOD(target, "initTTYWatcher", InitTTYWatcher);
NODE_SET_METHOD(target, "destroyTTYWatcher", DestroyTTYWatcher);
NODE_SET_METHOD(target, "startTTYWatcher", StartTTYWatcher);
NODE_SET_METHOD(target, "stopTTYWatcher", StopTTYWatcher);
} }

Write Preview
Loading…
Cancel
Save