{ 'name' : 'sven' }

{ title:'Pro JavaScript with MooTools' , author:'Mark Obcena' }

{ 'releaseDate':'1/1/11' } ,  { 'releaseDate':'5/1/11' }

[{
        country: 'UK',
        releaseDate: '1/1/11'
 },
 {
        country: 'ZA',
        releaseDate: '6/1/12'
}]

{
   title: 'Pro JavaScript with MooTools',
   author: 'Mark Obcena',
   releaseDates: [
      {
         country: 'UK',
         date: '1/1/11'
      },
      {
         country: 'ZA',
         date: '6/1/12'
      }
   ]
}
  Documents

function(doc) {
    emit(doc.title, doc.author);
}

function(doc) {
    if( ( doc.title && !doc.author ) || 
                ( doc.title && doc.author == 'unknown') )
                        emit(doc.title, 'missing author');
}

//http://blog.owned.co.za v8 Javascript Helper Function ,
//Give this function the c++ object (an instance) to wrap, 
//and it returns a JS object to expose things under.
//Note theres 2 functions here , 
//the top one is used by the ExposeClass function

template 
v8::Handle WrapClass(T* y)
{
        // Handle scope for temporary handles, 
        v8::HandleScope handle_scope;
        v8::Persistent  class_template_;
        
        v8::Handle rt = v8::ObjectTemplate::New();
        
        //The raw template is the ObjectTemplate
        // (that can be exposed to script too)
        //but is maintained internally.
        rt->SetInternalFieldCount(1);
        
        //Create the actual template object, 
        class_template_ = v8::Persistent::New(rt);
        
        //Create the new handle to return, and set its template type 
        v8::Handle result = class_template_->NewInstance();
        v8::Handle class_ptr
        class_ptr = v8::External::New(static_cast(y)); 
        
        //Point the 0 index Field to the c++ pointer for unwrapping later
        result->SetInternalField(0, class_ptr);
        
        //Return the value, releasing the other handles on its way.
        return handle_scope.Close(result);
} 


template
v8::Handle ExposeClass(v8::Persistent context, 
                                   T* y, 
                                   v8::Handle exposedName, 
                                   v8::PropertyAttribute props)
{
        v8::HandleScope handle_scope;
        
         v8::Handle obj = Core::Script::WrapClass(y);
        context->Global()->Set(exposedName, obj, props);
        
        return handle_scope.Close(obj);
}

//http://blog.owned.co.za v8 Javascript Helper Function ,
//Give this function the v8 JS object to unwrap, and the class to unwrap to.
                
template 
T* UnwrapClass(v8::Handle obj) 
{
        v8::Handle field;
        field = v8::Handle::Cast(obj->GetInternalField(0));
        void* ptr = field->Value();
        return static_cast(ptr);
}

class cCore
{

public:

        //This is a simple example, 
        //do not copy this as a real class.
        cCore(){};
        ~cCore() {};

        //We need a persistant handle to the core in scripts, a non persistant
        //v8::Handle will get lost in the handle scopes, 
        //and throw some weird exceptions to hunt down. 
        //Wrap class and unwrap class return 
        //NON persistant handles, so store your own 
        //persistant ones if you want to 
        //use it outside of the first handle scope.

        //core script object,  "core" in scripts.
        v8::Persistent cso_core;                                    

        //We expose some functions in our class to the scripts from c++, 
        //By wrapping an object (cso_core above) and the attaching functions
        //to that object. Those functions, when called from javascript - 
        //end up here.

        //The functions are self explanatory.

        //Print some text to the console/ui console
        static v8::Handle xecho(const v8::Arguments& args);         
        //execute a javascript file       
        static v8::Handle xexec(const v8::Arguments& args);         
        //exit all systems and shutdown       
        static v8::Handle xexit(const v8::Arguments& args);                
                                        
}; //end class declaration

//Just for clarity sake, so you can see my workflow.
void cScriptSystem::startup()
{
        //Create a script engine for the core
        v8::HandleScope handle_scope;

        //Create a context for the system to use 
        //(i have just one at this point)
        coreContext = v8::Context::New(NULL, global);

        //Enter the main context, making it active.
        v8::Context::Scope context_scope(coreContext);

        exposeCore(); //see below
};
                
//And the code to expose the class, 
void cScriptSystem::exposeCore()
{
        v8::HandleScope handlescope;

        //This will be reused to expose multiple 
        //classes, short name for easy code.
        v8::Handle cc;
                        
        //get the JS version of the C++ object, 
        //note that core is simply Core::cCore* core; 
        cc = ExposeClass< Core::cCore >(coreContext, core,  
                                         v8::String::New("core"), 
                                         v8::ReadOnly);
                        
        //set the persistant handle for use outside of this handlescospe
        core->cso_core = v8::Persistent::New(cc);

        //Give the functions to the object. 
        //This makes the functions come out as 
        //core.echo(), core.exec(), core.exit() in scripts.
        Expose(core->cso_core, v8::String::New("echo") , 
               v8::InvocationCallback(Core::cCore::xecho));
        Expose(core->cso_core, v8::String::New("exec") , 
               v8::InvocationCallback(Core::cCore::xexec));
        Expose(core->cso_core, v8::String::New("exit") , 
               v8::InvocationCallback(Core::cCore::xexit));

};

v8::Handle cCore::xexit(const v8::Arguments& args)
{
        //args.Holder() is the object that the function was invoked upon. 
        //This means it could be exposed to 2 classes, 
        //under different types so be sure
        //that you dont just randomly unwrap into the wrong container type.
                        
        Core::cCore* core = UnwrapClass( args.Holder() );
                                
        //The code inside the normal exit function is identical, 
        //so i can just call the normal c++ code directly.                
        core->startShutdown();
                        
        //This is to return void, basically.
        return v8::Undefined();
}

void Expose(v8::Handle intoObject, v8::Handle namev8String, v8::InvocationCallback funcID)
{
    v8::HandleScope handle_scope;

    v8::Handle thisFunc;
    thisFunc = v8::FunctionTemplate::New(funcID);
    intoObject->Set(namev8String, thisFunc->GetFunction());
}

//you can now use it std::string(*somestdstring)
v8::String::Utf8Value        somestdstring ( args[0] );  
                
        //you can now use it *somecstring (same as const char* somecstring;)
v8::String::Utf8Value        somecstring ( args[1] );        

        //normal double, 
double somedouble = args[2]->ToNumber()->Value();
        //booleans
bool somebool = args[3]->ToBoolean()->BooleanValue(); 
        //and integers.
int someint = args[4]->ToInt32()->Int32Value();        
                
//And one last thing, giving javascript meaningful return values. 
//This should be more than enough to let you figure out how simple
//v8 makes things for you on the c++ side.
                
        return handle_scope.Close(v8::Number::New(somedouble));
        return handle_scope.Close(v8::Int32::New(someint));
        return handle_scope.Close(v8::Boolean::New(somebool));

// Client side tool for pinging another player in the game
// Author : FuzzYspo0N
// Etc

//First, in order to create a tool on the client and server side,
//we simply assign a variable as a tool type. This might fail if 
//there is already a tool with this name - this returns undefined.

    var corePingTool = new core.tool("corePingTool");

//Maybe something simple to register a tool with a defined 
//callback for users. This global tool shows up at the shell,
// as a "command line" tool,and if a tool invokes
//a ui then it is not run via command shell but explicitly

    core.tool.registerGlobalTool("ping", "client name, ping count ");

//onExecute gets called whenever someone tries to ping 
//(either called via ui or via the above command line)
//Variable arguments handed in 
var corePingTool.onExecute = function(param)
{
        // 0 is reserved, so 1 is client name. 2 is ping count.
    var clientName = param[1];
    var pingCount = param[2];
        
    if(pingCount == core.invalid)
    {
        pingCount = 1;
    }
        
    //if we have a user like this, we can use em
    var userId = core.users.isAUser(clientName);
    if(userId != core.users.invalidUser)
    {
        //Create a new network javascript object. 
        //This object handles network packing/streams internally.
        //The to dev, this is simple - a javascript object. 
        //Push data into the stream, and be done.
                
        //The toolId is to header the packet type, for the server
        //to know what to do with it.
        var pck = new core.net.packet(this.toolId);
                
        //Add our data into the packet for the server to care
        pck.push(userId);
        pck.push(pingCount);
                
        //Give it a callback when its feeling talkative
        pck.response = this.onResponse;
                
        //Send it to the server
        pck.send();
    }
}


//The servers response to a ping command
var corePingTool.onResponse = function(param)
{
    //0 reserved, 1 is always the response code, 2 is the result
    //(known, from server side), 3 is the client requested
    if(param[1] == core.net.success)
    {
        //should output something like 
        //    ping response 128ms from " DumbassTeh" 
        
            var end = ' from " ' + param[3] + ' " ';
            echo('Ping response ' + param[2] + 'ms' + end);
        }
        else
        {
            //message box failure
        }
}

// Server side tool for pinging another player in the game
// Author : FuzzYspo0N
// Etc

//expects - a packet with 
    //pop 1 - sourceUserId 
    //pop 2 - destUserId
    //pop 3 - ping count
    
 //context globals
 
//var toolId is handed in from the system

var corePingTool_Main = function( pck)
{
    //Pck is basically a javascript array, and pop will
    //simply keep a "stackIndex" internally. So in essence
    //what you can see here is 
    // stackIndex += 1;
    // return pck[stackIndex - 1];
    
    var sourceId = pck.pop();
    var destId = pck.pop();
    var pingCount = pck.pop();
    
    for(i = 0; i 


Comments, views, ideas, etc - Welcome. Please, i like ideas.

Update!! 

I am attaching a mockup of how the tools *could* work , for development of the OS features. This is why i need feedback, is it plausible to expect some non developers to enjoy modifiying their desktop more than just a background image? etc.
Click on the image to see the full one.

[caption id="attachment_110" align="aligncenter" width="450" caption="Developer tool interface? Why not."][/caption]