public:

static void Initialize(Handle<Object> target) {

StreamWrap::Initialize(target);

HandleScope scope;

Local<FunctionTemplate> t = FunctionTemplate::New(New);

t->SetClassName(String::NewSymbol("TTY"));

t->InstanceTemplate()->SetInternalFieldCount(1);

NODE_SET_PROTOTYPE_METHOD(t, "close", HandleWrap::Close);

NODE_SET_PROTOTYPE_METHOD(t, "unref", HandleWrap::Unref);

NODE_SET_PROTOTYPE_METHOD(t, "ref", HandleWrap::Ref);

NODE_SET_PROTOTYPE_METHOD(t, "readStart", StreamWrap::ReadStart);

NODE_SET_PROTOTYPE_METHOD(t, "readStop", StreamWrap::ReadStop);

NODE_SET_PROTOTYPE_METHOD(t, "write", StreamWrap::Write);

NODE_SET_PROTOTYPE_METHOD(t, "getWindowSize", TTYWrap::GetWindowSize);

NODE_SET_PROTOTYPE_METHOD(t, "setRawMode", SetRawMode);

NODE_SET_METHOD(target, "isTTY", IsTTY);

NODE_SET_METHOD(target, "guessHandleType", GuessHandleType);

target->Set(String::NewSymbol("TTY"), t->GetFunction());

}

private:

static Handle<Value> GuessHandleType(const Arguments& args) {

HandleScope scope;

int fd = args[0]->Int32Value();

assert(fd >= 0);

uv_handle_type t = uv_guess_handle(fd);

switch (t) {

case UV_TTY:

return scope.Close(String::New("TTY"));

case UV_NAMED_PIPE:

return scope.Close(String::New("PIPE"));

case UV_FILE:

return scope.Close(String::New("FILE"));

default:

assert(0);

return v8::Undefined();

}

}

static Handle<Value> IsTTY(const Arguments& args) {

HandleScope scope;

int fd = args[0]->Int32Value();

assert(fd >= 0);

return uv_guess_handle(fd) == UV_TTY ? v8::True() : v8::False();

}

static Handle<Value> GetWindowSize(const Arguments& args) {

HandleScope scope;

UNWRAP

int width, height;

int r = uv_tty_get_winsize(&wrap->handle_, &width, &height);

if (r) {

SetErrno(uv_last_error(uv_default_loop()));

return v8::Undefined();

}

Local<v8::Array> a = v8::Array::New(2);

a->Set(0, Integer::New(width));

a->Set(1, Integer::New(height));

return scope.Close(a);

}

static Handle<Value> SetRawMode(const Arguments& args) {

HandleScope scope;

UNWRAP

int r = uv_tty_set_mode(&wrap->handle_, args[0]->IsTrue());

if (r) {

SetErrno(uv_last_error(uv_default_loop()));

}

return scope.Close(Integer::New(r));

}

static Handle<Value> New(const Arguments& args) {

HandleScope scope;

// This constructor should not be exposed to public javascript.

// Therefore we assert that we are not trying to call this as a

// normal function.

assert(args.IsConstructCall());

int fd = args[0]->Int32Value();

assert(fd >= 0);

TTYWrap* wrap = new TTYWrap(args.This(), fd, args[1]->IsTrue());

assert(wrap);

wrap->UpdateWriteQueueSize();

return scope.Close(args.This());

}

TTYWrap(Handle<Object> object, int fd, bool readable)

: StreamWrap(object, (uv_stream_t*)&handle_) {

uv_tty_init(uv_default_loop(), &handle_, fd, readable);

}

uv_tty_t handle_;