Category Archives: coding

Virtual Earth point in bounding box test

I’m currently working with the Microsoft Virtual Earth SDK and wanted to test if a point is inside a box as where coordinates are specified using latitude and longitude.

It appears there are no built in function the API that does this, so this is what I came up with. Please note the special case where the bounding box overlaps the 180th degree longitude.

/**
* Returns true if point is in rectangle.
*
* @param {VELatLong} point Point to check.
* @param {VELatLongRectangle} rect Bounding box.
*/
function isPointInRect(point, rect) {
return ( (rect.TopLeftLatLong.Longitude <= rect.BottomRightLatLong.Longitude && // longitude rect.TopLeftLatLong.Longitude <= point.Longitude && rect.BottomRightLatLong.Longitude >= point.Longitude)
|| (rect.TopLeftLatLong.Longitude > rect.BottomRightLatLong.Longitude && // longitude crosses 180 degrees
rect.TopLeftLatLong.Longitude >= point.Longitude &&
rect.BottomRightLatLong.Longitude <= point.Longitude) ) && (rect.TopLeftLatLong.Latitude >= point.Latitude && // latitude
rect.BottomRightLatLong.Latitude <= point.Latitude); } [/sourcecode] This may be used, among many things, to test if a pushpin shape is within the current map view, and if it isn't the map is panned to make it visible: [sourcecode language='javascript'] var point = shape.GetPoints()[0]; if (!isPointInRect(point, map.GetMapView())) { map.PanToLatLong(point); } [/sourcecode]

Viewing Flash Player debug log flashlog.txt

Using the trace() function output is written to the file flashlog.txt if the debug version of Flash Player is used.

Verify that you are running the debug version at this page, if not you may download it here.

Then the Flash Player must be configured to enable logging using the mm.cfg file. It’s location is OS dependent, as well as the (hard-coded) location of the resulting flashlog.txt file. Location and possible settings of the mm.cfg file are documented here.

Using Mac OSX or Linux a convenient way to view the log file is to use tail -f from the command line, e.g.:

tail -f /Users/<user>/Library/Preferences/Macromedia/Flash Player/Logs/flashlog.txt

Detect if ExCanvas is loaded

When using ExplorerCanvas (excanvas) to emulate the Canvas object in Internet Explorer it might be a good idea to check that the excanvas lib really is loaded before trying to create a context object. If not, an informative error message may be displayed instead of some cryptic “object doesn’t support this property”.

Here is a way to check if excanvas.js has been loaded.

if (typeof window.CanvasRenderingContext2D == 'undefined' &&
    typeof G_vmlCanvasManager == 'undefined') {
        alert("ExCanvas not loaded!");
}

Cross-site data retrieval using JSONP

Traditional data retrieval (in JSON, XML or whatever) using XMLHttpRequest is limited to requests on the same domain. A way to work around this limitation is to use JSONP. The ‘P’ stands for Padding.

The main concept is to dynamically create a script tag and set its source attribute to the URL of the service which you would like your script to communicate with. The service responds with the relevant data in JSON format, but wraps it in a function call (that’s the padding!). The browser will evaluate the JavaScript immediately it is loaded and execute the function call with the JSON retrieved data as a regular object as it’s argument.

If the backend service takes the function name used to wrap the JSON data as an argument in the query string it is possible for the initiating script to set up a callback of choice.

If the backend service is called (i.e. setting the script src attribute) using the following URL:

http://www.stpe.se/service?callback=myMethod

The response from the backend service may look something like:

myMethod({firstValue: 123, secondValue: 456});

The only difference from a traditional JSON service is the padding with the function call (hence the P in JSONP). Of course additional parameters to the backend service may be appended as arguments or part of the URL in a RESTful way.

Here is an example of a JavaScript function that initiates the callback by creating a script tag:

function initJSONP(url) {
    // create script tag
    var script = document.createElement("script");
    script.setAttribute("type", "text/javascript");

    // append timestamp to avoid browser caching
    url += (url.indexOf("?") == -1 ? "?" : "&amp;amp;amp;") + (new Date().getTime());

    // set script source to the service that responds with thepadded JSON data
    script.setAttribute("src", url);

    // insert script tag
    document.body.appendChild(script);

    // remove script tag by timeout (remove responsibility from callback)
    setTimeout(function() {
        document.body.removeChild(script);
    }, 2000);
}

Given our previous example it would be called using:

initJSONP("http://www.stpe.se/service?callback=myMethod");

If the same URL is called multiple times it may be a good idea to append something relatively unique (timestamp in this example) to the URL to avoid having the browser cache the call.

The other peculiarity is how the just created script tag is removed from the document. In this example I’m using a timeout of 2 seconds. The advantage is that the removal is done automatically and there is no responsibility of the callback function to clean up the document (which makes sense since the callback function may be a regular function also invoked from the main JavaScript itself). The disadvantage is if the service takes more than 2 seconds to respond, then the callback will never be made. Your milage may vary, so apply the method that suits your particular demands.

That’s all there is. 🙂

Javascript Array.indexOf() and Array.remove()

Useful convenience methods for array manipulation in Javascript.

Array.indexOf()

Find index of given element in array. This method is implemented in some browsers, but not all.

if (!Array.prototype.indexOf)
{
    /**
     * Add array.indexOf() functionality (exists in >FF 1.5 but not in IE)
     *
     * @param {Object} elem Element to find.
     * @param {Number} [from] Position in array to look from.
     */    
    Array.prototype.indexOf = function(elem /*, from*/) {
        var len = this.length;
        
        var from = Number(arguments[1]) || 0;
        from = (from < 0) ? Math.ceil(from) : Math.floor(from);
        if (from < 0) {
            from += len;
        }
        
        for (; from < len; from++) {
            if (from in this && this&#91;from&#93; === elem) {
                return from;
            }
        }
        
        return -1;
    };
}
&#91;/sourcecode&#93;

<h3>Array.remove()</h3>
Remove element in array (depends on indexOf method).


if (!Array.prototype.remove)
{
    /**
     * Add array.remove() convenience method to remove element from array.
     * 
     * @param {Object} elem Element to remove.
     */
    Array.prototype.remove = function(elem) {
        var index = this.indexOf(elem);
        
        if (index !== -1) {
            this.splice(index, 1);
        }        
    };
}

Simply add these two your Javascript file augment the functionality with the existing Array implementation.