expose grid.painted() to match image.painted()

src/mapnik_grid.cpp

@@ -34,6 +34,7 @@ void Grid::Initialize(Handle<Object> target) {
     NODE_SET_PROTOTYPE_METHOD(constructor, "view", view);
     NODE_SET_PROTOTYPE_METHOD(constructor, "width", width);
     NODE_SET_PROTOTYPE_METHOD(constructor, "height", height);
+    NODE_SET_PROTOTYPE_METHOD(constructor, "painted", painted);
 
     // properties
     ATTR(constructor, "key", get_prop, set_prop);
@@ -121,6 +122,14 @@ Handle<Value> Grid::New(const Arguments& args)
     return Undefined();
 }
 
+Handle<Value> Grid::painted(const Arguments& args)
+{
+    HandleScope scope;
+
+    Grid* g = ObjectWrap::Unwrap<Grid>(args.This());
+    return scope.Close(Boolean::New(g->get()->painted()));
+}
+
 Handle<Value> Grid::width(const Arguments& args)
 {
     HandleScope scope;

src/mapnik_grid.hpp

@@ -19,11 +19,11 @@ class Grid: public node::ObjectWrap {
     static Handle<Value> New(const Arguments &args);
     static Handle<Value> encodeSync(const Arguments &args);
     static Handle<Value> encode(const Arguments &args);
+    static Handle<Value> fields(const Arguments &args);
+    static Handle<Value> view(const Arguments &args);
     static Handle<Value> width(const Arguments &args);
     static Handle<Value> height(const Arguments &args);
-    static Handle<Value> view(const Arguments &args);
-
-    static Handle<Value> fields(const Arguments &args);
+    static Handle<Value> painted(const Arguments &args);
 
     static Handle<Value> get_prop(Local<String> property,
                          const AccessorInfo& info);

src/mapnik_map.cpp

@@ -1144,8 +1144,15 @@ Handle<Value> Map::render(const Arguments& args)
 
                 if (layer_idx >= layer_num) {
                     std::ostringstream s;
-                    s << "Zero-based layer index '" << layer_idx << "' not valid, only '"
-                      << layers.size() << "' layers are in map";
+                    s << "Zero-based layer index '" << layer_idx << "' not valid, ";
+                    if (layer_num > 0)
+                    {
+                        s << "only '" << layers.size() << "' layers exist in map";
+                    }
+                    else
+                    {
+                        s << "no layers found in map";
+                    }
                     return ThrowException(Exception::TypeError(String::New(s.str().c_str())));
                 }
             } else {

test/grid.test.js

@@ -0,0 +1,87 @@
+var mapnik = require('mapnik');
+var assert = require('assert');
+var fs = require('fs');
+var path = require('path');
+
+exports['test grids'] = function(beforeExit) {
+    // no 'new' keyword
+    assert.throws(function() { mapnik.Grid(1, 1); });
+
+    // invalid args
+    assert.throws(function() { new mapnik.Grid(); });
+    assert.throws(function() { new mapnik.Grid(1); });
+    assert.throws(function() { new mapnik.Grid('foo'); });
+    assert.throws(function() { new mapnik.Grid('a', 'b', 'c'); });
+
+    var grid = new mapnik.Grid(256, 256);
+    assert.ok(grid instanceof mapnik.Grid);
+
+    assert.equal(grid.width(), 256);
+    assert.equal(grid.height(), 256);
+    var v = grid.view(0, 0, 256, 256);
+    assert.ok(v instanceof mapnik.GridView);
+    assert.equal(v.width(), 256);
+    assert.equal(v.height(), 256);
+    assert.equal(grid.encodeSync().length, v.encodeSync().length);
+
+
+    var grid_blank = new mapnik.Grid(4,4);
+    assert.equal(grid_blank.painted(),false);
+    assert.equal(grid_blank.background,undefined);
+
+    var m = new mapnik.Map(4,4);
+    var l = new mapnik.Layer('test');
+    m.add_layer(l);
+
+    m.render(grid_blank,{layer:0},function(err,grid_blank) {
+        assert.equal(grid_blank.painted(),false);
+        assert.equal(grid_blank.background,undefined);
+    });
+
+    var grid_blank2 = new mapnik.Grid(4,4);
+    assert.equal(grid_blank2.painted(),false);
+    assert.equal(grid_blank2.background,undefined);
+
+    var m2 = new mapnik.Map(4,4);
+    var l = new mapnik.Layer('test');
+    m2.add_layer(l);
+
+    m2.background = new mapnik.Color('green');
+    m2.render(grid_blank2,{layer:0},function(err,grid_blank2) {
+        assert.equal(grid_blank2.painted(),false);
+        //assert.ok(grid_blank2.background);
+    });
+
+
+    var grid_blank3 = new mapnik.Grid(4,4);
+    assert.equal(grid_blank3.painted(),false);
+    assert.equal(grid_blank3.background,undefined);
+
+    var m3 = new mapnik.Map(4,4);
+    var s = '<Map>';
+    s += '<Style name="points">';
+    s += ' <Rule>';
+    s += '  <PointSymbolizer />';
+    s += ' </Rule>';
+    s += '</Style>';
+    s += '</Map>';
+    m3.fromStringSync(s);
+
+    var mem_datasource = new mapnik.MemoryDatasource({'extent':'-180,-90,180,90'});
+    mem_datasource.add({ 'x':0, 'y':0 });
+    mem_datasource.add({ 'x':1, 'y':1 });
+    mem_datasource.add({ 'x':2, 'y':2 });
+    mem_datasource.add({ 'x':3, 'y':3 });
+    var l = new mapnik.Layer('test');
+    l.srs = m3.srs;
+    l.styles = ["points"];
+    l.datasource = mem_datasource;
+    m3.add_layer(l);
+    m3.zoomAll();    
+    m3.render(grid_blank3,{layer:0},function(err,grid_blank3) {
+        assert.equal(grid_blank3.painted(),true);
+        // TODO - expose grid background
+        //assert.equal(grid_blank3.background,undefined);
+    });
+
+};