test_Feature.html | searchcode

/docs/map/openlayers/tests/Handler/test_Feature.html

https://github.com/jj0hns0n/oam-original · HTML · 253 lines · 221 code · 32 blank · 0 comment · 0 complexity · 01ee9132f190e468c7169f08afd965eb MD5 · raw file

<html>
<head>
  <script src="../../lib/OpenLayers.js"></script>
  <script type="text/javascript">
    function test_Handler_Feature_constructor(t) {
        t.plan(4);
        var control = new OpenLayers.Control();
        control.id = Math.random();
        var layer = "boo";
        var callbacks = {foo: "bar"};
        var options = {bar: "foo"};
        
        var oldInit = OpenLayers.Handler.prototype.initialize;
        
        OpenLayers.Handler.prototype.initialize = function(con, call, opt) {
            t.eq(con.id, control.id,
                 "constructor calls parent with the correct control");
            t.eq(call, callbacks,
                 "constructor calls parent with the correct callbacks");
            t.eq(opt, options,
                 "constructor calls parent with the correct options");
        }
        var handler = new OpenLayers.Handler.Feature(control, layer,
                                                     callbacks, options);
        
        t.eq(handler.layer, "boo",
             "layer property properly set");

        OpenLayers.Handler.prototype.initialize = oldInit;
    }

    function test_Handler_Feature_activate(t) {
        t.plan(4);
        var map = new OpenLayers.Map('map');
        var control = new OpenLayers.Control();
        map.addControl(control);
        var layer = new OpenLayers.Layer();
        map.addLayer(layer);
        var handler = new OpenLayers.Handler.Feature(control, layer);
        handler.active = true;
        var activated = handler.activate();
        t.ok(!activated,
             "activate returns false if the handler was already active");
        handler.active = false;
        
        var zIndex = layer.div.style.zIndex;
        activated = handler.activate();
        t.ok(activated,
             "activate returns true if the handler was not already active");
        t.eq(handler.layerIndex, zIndex,
             "layerIndex property properly set");
        t.eq(parseInt(layer.div.style.zIndex),
             map.Z_INDEX_BASE['Popup'] - 1,
             "layer z-index properly adjusted");
        
    }
    function test_Handler_Feature_events(t) {
        t.plan(25);
        
        var map = new OpenLayers.Map('map');
        var control = new OpenLayers.Control();
        map.addControl(control);
        var layer = new OpenLayers.Layer();
        map.addLayer(layer);
        var handler = new OpenLayers.Handler.Feature(control, layer);
 
        // list below events that should be handled (events) and those
        // that should not be handled (nonevents) by the handler
        var events = ["mousedown", "mouseup", "mousemove", "click", "dblclick"];
        var nonevents = ["mouseout", "resize", "focus", "blur"];
        map.events.registerPriority = function(type, obj, func) {
            var output = func();
            // Don't listen for setEvent handlers (#902)
            if (typeof output == "string") {
                t.eq(OpenLayers.Util.indexOf(nonevents, type), -1,
                     "registered method is not one of the events " +
                     "that should not be handled");
                t.ok(OpenLayers.Util.indexOf(events, type) > -1,
                     "activate calls registerPriority with browser event: " + type);
                t.eq(typeof func, "function",
                     "activate calls registerPriority with a function");
                t.eq(func(), type,
                     "activate calls registerPriority with the correct method:"+type);
                t.eq(obj["CLASS_NAME"], "OpenLayers.Handler.Feature",
                     "activate calls registerPriority with the handler");
            }     
        }
        
        // set browser event like properties on the handler
        for(var i=0; i<events.length; ++i) {
            setMethod(events[i]);
        }
        function setMethod(key) {
            handler[key] = function() {return key};
        }
 
        var activated = handler.activate();
 
    }
 
    function test_Handler_feature_geometrytype_limit(t) {
        t.plan(2);
        var feature = new OpenLayers.Feature.Vector(new OpenLayers.Geometry.Point(0,0));
        var map = new OpenLayers.Map('map');
        var control = new OpenLayers.Control();
        map.addControl(control);
        var layer = new OpenLayers.Layer();
        layer.getFeatureFromEvent = function(evt) { return feature };
        map.addLayer(layer);
        var handler = new OpenLayers.Handler.Feature(control, layer, {}, {'geometryTypes':['OpenLayers.Geometry.Point']});
        handler.activate();
        handler.callback = function(type,featurelist) {
            t.eq(featurelist[0].id, feature.id, "Correct feature called back on");
        }
        handler.select("foo", {}); 
        handler.feature = null;
        handler.callback = function(type,featurelist) {
            t.fail("Shouldn't have called back on " + featurelist[0].geometry);
        }    
        feature = new OpenLayers.Feature.Vector(new OpenLayers.Geometry.LineString(0,0));
        handler.select("foo", {}); 
    }
    function test_Handler_Feature_callbacks(t) {
        t.plan(75);
        
        var map = new OpenLayers.Map('map', {controls: []});
        var control = new OpenLayers.Control();
        map.addControl(control);
        var layer = new OpenLayers.Layer();
        map.addLayer(layer);
        
        var evtsToTest = [
            {
                shortName: "down",
                longName: "mousedown"
            },
            {
                shortName: "move",
                longName: "mousemove"
            },
            {
                shortName: "up",
                longName: "mouseup"
            },
            {
                shortName: "click",
                longName: "click"
            },
            {
                shortName: "dblclick",
                longName: "dblclick"
            }
       ];
 
        var numEvents = {};
        var callbacks = {};
 
        var newFeature;
        var oldFeature;
 
        function getCallback(evt, feature) {
            return function(f) {
                t.ok(f == feature, "callback called with proper feature");
                numEvents[evt]++;
            };
        }
 
        layer.getFeatureFromEvent = function(evt) { return newFeature; };
 
        var handler = new OpenLayers.Handler.Feature(control, layer, callbacks);
        handler.activate();
 
        for (var i = 0; i < evtsToTest.length; i++) {
            evt = evtsToTest[i];
 
            var evtShortName = evt.shortName;
            var evtLongName = evt.longName;
 
            var evtPx = {xy: new OpenLayers.Pixel(Math.random(), Math.random())};
 
            handler.feature = null;
 
            numEvents[evtShortName] = 0;
            numEvents["over"] = 0;
            numEvents["out"] = 0;
            oldFeature = null;
            newFeature = new OpenLayers.Feature.Vector();
            callbacks[evtShortName] = getCallback(evtShortName, newFeature);
            callbacks["over"] = getCallback("over", newFeature);
            callbacks["out"] = getCallback("out", oldFeature);
            map.events.triggerEvent(evtLongName, evtPx);
            t.ok(numEvents[evtShortName] == 1, evtShortName + " triggered click callback");
            t.ok(numEvents["over"] == 1, evtShortName + " triggered over callbacks");
            t.ok(numEvents["out"] == 0, evtShortName + " did not trigger out callback");
 
            numEvents[evtShortName] = 0;
            numEvents["over"] = 0;
            numEvents["out"] = 0;
            oldFeature = newFeature;
            newFeature = new OpenLayers.Feature.Vector();
            callbacks[evtShortName] = getCallback(evtShortName, newFeature);
            callbacks["over"] = getCallback("over", newFeature);
            callbacks["out"] = getCallback("out", oldFeature);
            map.events.triggerEvent(evtLongName, evtPx);
            t.ok(numEvents[evtShortName] == 1, evtShortName + " triggered click callback");
            t.ok(numEvents["over"] == 1, evtShortName + " triggered over callbacks");
            t.ok(numEvents["out"] == 1, evtShortName + " triggered out callback");
 
            numEvents[evtShortName] = 0;
            numEvents["over"] = 0;
            numEvents["out"] = 0;
            oldFeature =  newFeature;
            callbacks[evtShortName] = getCallback(evtShortName, newFeature);
            callbacks["over"] = getCallback("over", newFeature);
            callbacks["out"] = getCallback("out", oldFeature);
            map.events.triggerEvent(evtLongName, evtPx);
            t.ok(numEvents[evtShortName] == 1, evtShortName + " triggered click callback");
            t.ok(numEvents["over"] == 0, evtShortName + " did not trigger over callbacks");
            t.ok(numEvents["out"] == 0, evtShortName + " did not trigger out callback");
        }
    }

    function test_Handler_Feature_deactivate(t) {
        t.plan(3);
        var map = new OpenLayers.Map('map');
        var control = new OpenLayers.Control();
        map.addControl(control);
        var layer = new OpenLayers.Layer();
        map.addLayer(layer);
        var handler = new OpenLayers.Handler.Feature(control, layer);
        handler.active = false;
        var deactivated = handler.deactivate();
        t.ok(!deactivated,
             "deactivate returns false if the handler was not already active");
        
        handler.active = true;
        handler.layerIndex = Math.floor(Math.random() * 10);

        deactivated = handler.deactivate();
        t.ok(deactivated,
             "deactivate returns true if the handler was active already");
        t.eq(parseInt(layer.div.style.zIndex),
             handler.layerIndex,
             "deactivate sets the layer z-index back");
    }


  </script>
</head>
<body>
    <div id="map" style="width: 300px; height: 150px;"/>
</body>
</html>