Index: trunk/FACT++/src/InterpreterV8.cc
===================================================================
--- trunk/FACT++/src/InterpreterV8.cc	(revision 14637)
+++ trunk/FACT++/src/InterpreterV8.cc	(revision 14638)
@@ -119,5 +119,5 @@
 }
 
-void InterpreterV8::ThreadTimeout(int &id, Persistent<Function> func, uint32_t ms)
+void InterpreterV8::Thread(int &id, Persistent<Function> func, uint32_t ms)
 {
     const Locker lock;
@@ -148,21 +148,24 @@
     fThreadIds.erase(id);
 
-    if (!HandleException(exception, "dim.timeout"))
+    if (!HandleException(exception, "thread"))
         V8::TerminateExecution(fThreadId);
 }
 
-Handle<Value> InterpreterV8::FuncTimeout(const Arguments& args)
-{
+Handle<Value> InterpreterV8::FuncThread(const Arguments& args)
+{
+    if (!args.IsConstructCall())
+        return ThrowException(String::New("Thread must be called as constructor."));
+
     if (args.Length()!=2)
-        return ThrowException(String::New("Number of arguments must be at least 1."));
-
-    if (args.Length()==0)
-        return ThrowException(String::New("Number of arguments must be at least 1."));
+        return ThrowException(String::New("Number of arguments must be two."));
+
+    if (!args[0]->IsUint32())
+        return ThrowException(String::New("Argument 0 not an uint32."));
 
     if (!args[1]->IsFunction())
         return ThrowException(String::New("Argument 1 not a function."));
 
-    if (!args[0]->IsUint32())
-        return ThrowException(String::New("Argument 0 not an uint32."));
+    //if (!args.IsConstructCall())
+    //    return Constructor(args);
 
     const HandleScope handle_scope;
@@ -175,6 +178,7 @@
 
     int id=-2;
-    fTimeout.push_back(thread(bind(&InterpreterV8::ThreadTimeout, this, ref(id), func, ms)));
-    {
+    fThreads.push_back(thread(bind(&InterpreterV8::Thread, this, ref(id), func, ms)));
+    {
+        // Allow the thread to lock, so we can get the thread id.
         const Unlocker unlock;
         while (id==-2)
@@ -182,22 +186,19 @@
     }
 
-    return Integer::New(id);
+    Handle<Object> This = args.This();
+
+    This->SetInternalField(0, Integer::New(id));
+    This->Set(String::New("kill"), FunctionTemplate::New(WrapKill)->GetFunction(), ReadOnly);
+
+    return Undefined();
 }
 
 Handle<Value> InterpreterV8::FuncKill(const Arguments& args)
 {
-    for (int i=0; i<args.Length(); i++)
-        if (!args[i]->IsInt32())
-            return ThrowException(String::New("All arguments must be int32."));
-
-    uint32_t cnt = 0;
-
-    for (int i=0; i<args.Length(); i++)
-    {
-        V8::TerminateExecution(args[i]->Int32Value());
-        cnt += fThreadIds.erase(args[i]->Int32Value());
-    }
-
-    return Integer::New(cnt);
+    const int id = args.This()->GetInternalField(0)->Int32Value();
+
+    V8::TerminateExecution(id);
+
+    return Boolean::New(fThreadIds.erase(id));
 }
 
@@ -674,4 +675,7 @@
 Handle<Value> InterpreterV8::FuncDatabase(const Arguments &args)
 {
+    if (!args.IsConstructCall())
+        return ThrowException(String::New("Database must be called as constructor."));
+
     if (args.Length()!=1)
         return ThrowException(String::New("Number of arguments must be 1."));
@@ -1702,5 +1706,4 @@
     dim->Set(String::New("getState"),  FunctionTemplate::New(WrapGetState),  ReadOnly);
     dim->Set(String::New("sleep"),     FunctionTemplate::New(WrapSleep),     ReadOnly);
-    dim->Set(String::New("timeout"),   FunctionTemplate::New(WrapTimeout),   ReadOnly);
     dim->Set(String::New("kill"),      FunctionTemplate::New(WrapKill),      ReadOnly);
     dim->Set(String::New("subscribe"), FunctionTemplate::New(WrapSubscribe), ReadOnly);
@@ -1729,4 +1732,9 @@
     db->InstanceTemplate()->SetInternalFieldCount(1);
     global->Set(String::New("Database"), db, ReadOnly);
+
+    Handle<FunctionTemplate> thread = FunctionTemplate::New(WrapThread);
+    thread->SetClassName(String::New("Thread"));
+    thread->InstanceTemplate()->SetInternalFieldCount(1);
+    global->Set(String::New("Thread"), thread, ReadOnly);
 
 #ifdef HAVE_NOVA
@@ -1818,7 +1826,7 @@
         const Unlocker unlock;
 
-        for (auto it=fTimeout.begin(); it!=fTimeout.end(); it++)
+        for (auto it=fThreads.begin(); it!=fThreads.end(); it++)
             it->join();
-        fTimeout.clear();
+        fThreads.clear();
     }
 
Index: trunk/FACT++/src/InterpreterV8.h
===================================================================
--- trunk/FACT++/src/InterpreterV8.h	(revision 14637)
+++ trunk/FACT++/src/InterpreterV8.h	(revision 14638)
@@ -36,6 +36,6 @@
     std::map<std::string, v8::Persistent<v8::Object>> fStateCallbacks;
 
-    // List of all timeout threads
-    std::vector<std::thread> fTimeout;
+    // List of all threads
+    std::vector<std::thread> fThreads;
 
     // List of all states already set
@@ -55,10 +55,10 @@
     v8::Handle<v8::Value> ExecuteInternal(const std::string &code);
 
-    void ThreadTimeout(int &id, v8::Persistent<v8::Function> func, uint32_t ms);
+    void Thread(int &id, v8::Persistent<v8::Function> func, uint32_t ms);
 
     v8::Handle<v8::Value> FuncWait(const v8::Arguments& args);
     v8::Handle<v8::Value> FuncSend(const v8::Arguments& args);
     v8::Handle<v8::Value> FuncSleep(const v8::Arguments& args);
-    v8::Handle<v8::Value> FuncTimeout(const v8::Arguments& args);
+    v8::Handle<v8::Value> FuncThread(const v8::Arguments& args);
     v8::Handle<v8::Value> FuncKill(const v8::Arguments& args);
     v8::Handle<v8::Value> FuncPrint(const v8::Arguments& args);
@@ -106,5 +106,5 @@
     static v8::Handle<v8::Value> WrapSend(const v8::Arguments &args)     { if (This) return This->FuncSend(args);     else return v8::Undefined(); }
     static v8::Handle<v8::Value> WrapSleep(const v8::Arguments &args)    { if (This) return This->FuncSleep(args);    else return v8::Undefined(); }
-    static v8::Handle<v8::Value> WrapTimeout(const v8::Arguments &args)  { if (This) return This->FuncTimeout(args);  else return v8::Undefined(); }
+    static v8::Handle<v8::Value> WrapThread(const v8::Arguments &args)   { if (This) return This->FuncThread(args);   else return v8::Undefined(); }
     static v8::Handle<v8::Value> WrapKill(const v8::Arguments &args)     { if (This) return This->FuncKill(args);     else return v8::Undefined(); }
     static v8::Handle<v8::Value> WrapExit(const v8::Arguments &args)     { if (This) return This->FuncExit(args);     else return v8::Undefined(); }