diff -r f7de8a24fc74 -r 1997dae651c6 src/js/iframe_embed/embedder.js
--- a/src/js/iframe_embed/embedder.js	Tue Feb 14 17:13:44 2012 +0100
+++ b/src/js/iframe_embed/embedder.js	Tue Feb 14 17:14:57 2012 +0100
@@ -3,3 +3,258 @@
    to the iframe url in the page url.   
 */
 
+IriSP = {};
+
+window.onhashchange = function() {
+  var url = window.location.href;
+  var frame = document.getElementById("metadataplayer_embed");
+
+  if ( url.split( "#" )[ 1 ] != null ) {
+       hashvalue = url.split("#")[1];
+       frame.contentWindow.postMessage({type: "hashchange", value: hashvalue}, "*");
+  }    
+};
+
+
+IriSP.handleMessages = function(e) {
+  var history = window.history;
+  
+  if ( !history.pushState ) {
+    return false;
+  }
+
+  if (e.data.type === "hashchange") {
+    console.log(e.data.value);
+    history.replaceState( {}, "", e.data.value);
+  }
+};
+
+// http://stackoverflow.com/questions/799981/document-ready-equivalent-without-jquery
+var ready = (function(){    
+
+    var readyList,
+        DOMContentLoaded,
+        class2type = {};
+        class2type["[object Boolean]"] = "boolean";
+        class2type["[object Number]"] = "number";
+        class2type["[object String]"] = "string";
+        class2type["[object Function]"] = "function";
+        class2type["[object Array]"] = "array";
+        class2type["[object Date]"] = "date";
+        class2type["[object RegExp]"] = "regexp";
+        class2type["[object Object]"] = "object";
+
+    var ReadyObj = {
+        // Is the DOM ready to be used? Set to true once it occurs.
+        isReady: false,
+        // A counter to track how many items to wait for before
+        // the ready event fires. See #6781
+        readyWait: 1,
+        // Hold (or release) the ready event
+        holdReady: function( hold ) {
+            if ( hold ) {
+                ReadyObj.readyWait++;
+            } else {
+                ReadyObj.ready( true );
+            }
+        },
+        // Handle when the DOM is ready
+        ready: function( wait ) {
+            // Either a released hold or an DOMready/load event and not yet ready
+            if ( (wait === true && !--ReadyObj.readyWait) || (wait !== true && !ReadyObj.isReady) ) {
+                // Make sure body exists, at least, in case IE gets a little overzealous (ticket #5443).
+                if ( !document.body ) {
+                    return setTimeout( ReadyObj.ready, 1 );
+                }
+
+                // Remember that the DOM is ready
+                ReadyObj.isReady = true;
+                // If a normal DOM Ready event fired, decrement, and wait if need be
+                if ( wait !== true && --ReadyObj.readyWait > 0 ) {
+                    return;
+                }
+                // If there are functions bound, to execute
+                readyList.resolveWith( document, [ ReadyObj ] );
+
+                // Trigger any bound ready events
+                //if ( ReadyObj.fn.trigger ) {
+                //  ReadyObj( document ).trigger( "ready" ).unbind( "ready" );
+                //}
+            }
+        },
+        bindReady: function() {
+            if ( readyList ) {
+                return;
+            }
+            readyList = ReadyObj._Deferred();
+
+            // Catch cases where $(document).ready() is called after the
+            // browser event has already occurred.
+            if ( document.readyState === "complete" ) {
+                // Handle it asynchronously to allow scripts the opportunity to delay ready
+                return setTimeout( ReadyObj.ready, 1 );
+            }
+
+            // Mozilla, Opera and webkit nightlies currently support this event
+            if ( document.addEventListener ) {
+                // Use the handy event callback
+                document.addEventListener( "DOMContentLoaded", DOMContentLoaded, false );
+                // A fallback to window.onload, that will always work
+                window.addEventListener( "load", ReadyObj.ready, false );
+
+            // If IE event model is used
+            } else if ( document.attachEvent ) {
+                // ensure firing before onload,
+                // maybe late but safe also for iframes
+                document.attachEvent( "onreadystatechange", DOMContentLoaded );
+
+                // A fallback to window.onload, that will always work
+                window.attachEvent( "onload", ReadyObj.ready );
+
+                // If IE and not a frame
+                // continually check to see if the document is ready
+                var toplevel = false;
+
+                try {
+                    toplevel = window.frameElement == null;
+                } catch(e) {}
+
+                if ( document.documentElement.doScroll && toplevel ) {
+                    doScrollCheck();
+                }
+            }
+        },
+        _Deferred: function() {
+            var // callbacks list
+                callbacks = [],
+                // stored [ context , args ]
+                fired,
+                // to avoid firing when already doing so
+                firing,
+                // flag to know if the deferred has been cancelled
+                cancelled,
+                // the deferred itself
+                deferred  = {
+
+                    // done( f1, f2, ...)
+                    done: function() {
+                        if ( !cancelled ) {
+                            var args = arguments,
+                                i,
+                                length,
+                                elem,
+                                type,
+                                _fired;
+                            if ( fired ) {
+                                _fired = fired;
+                                fired = 0;
+                            }
+                            for ( i = 0, length = args.length; i < length; i++ ) {
+                                elem = args[ i ];
+                                type = ReadyObj.type( elem );
+                                if ( type === "array" ) {
+                                    deferred.done.apply( deferred, elem );
+                                } else if ( type === "function" ) {
+                                    callbacks.push( elem );
+                                }
+                            }
+                            if ( _fired ) {
+                                deferred.resolveWith( _fired[ 0 ], _fired[ 1 ] );
+                            }
+                        }
+                        return this;
+                    },
+
+                    // resolve with given context and args
+                    resolveWith: function( context, args ) {
+                        if ( !cancelled && !fired && !firing ) {
+                            // make sure args are available (#8421)
+                            args = args || [];
+                            firing = 1;
+                            try {
+                                while( callbacks[ 0 ] ) {
+                                    callbacks.shift().apply( context, args );//shifts a callback, and applies it to document
+                                }
+                            }
+                            finally {
+                                fired = [ context, args ];
+                                firing = 0;
+                            }
+                        }
+                        return this;
+                    },
+
+                    // resolve with this as context and given arguments
+                    resolve: function() {
+                        deferred.resolveWith( this, arguments );
+                        return this;
+                    },
+
+                    // Has this deferred been resolved?
+                    isResolved: function() {
+                        return !!( firing || fired );
+                    },
+
+                    // Cancel
+                    cancel: function() {
+                        cancelled = 1;
+                        callbacks = [];
+                        return this;
+                    }
+                };
+
+            return deferred;
+        },
+        type: function( obj ) {
+            return obj == null ?
+                String( obj ) :
+                class2type[ Object.prototype.toString.call(obj) ] || "object";
+        }
+    }
+    // The DOM ready check for Internet Explorer
+    function doScrollCheck() {
+        if ( ReadyObj.isReady ) {
+            return;
+        }
+
+        try {
+            // If IE is used, use the trick by Diego Perini
+            // http://javascript.nwbox.com/IEContentLoaded/
+            document.documentElement.doScroll("left");
+        } catch(e) {
+            setTimeout( doScrollCheck, 1 );
+            return;
+        }
+
+        // and execute any waiting functions
+        ReadyObj.ready();
+    }
+    // Cleanup functions for the document ready method
+    if ( document.addEventListener ) {
+        DOMContentLoaded = function() {
+            document.removeEventListener( "DOMContentLoaded", DOMContentLoaded, false );
+            ReadyObj.ready();
+        };
+
+    } else if ( document.attachEvent ) {
+        DOMContentLoaded = function() {
+            // Make sure body exists, at least, in case IE gets a little overzealous (ticket #5443).
+            if ( document.readyState === "complete" ) {
+                document.detachEvent( "onreadystatechange", DOMContentLoaded );
+                ReadyObj.ready();
+            }
+        };
+    }
+    function ready( fn ) {
+        // Attach the listeners
+        ReadyObj.bindReady();
+
+        var type = ReadyObj.type( fn );
+
+        // Add the callback
+        readyList.done( fn );//readyList is result of _Deferred()
+    }
+    return ready;
+})();
+
+ready(function() { window.addEventListener('message', IriSP.handleMessages, false); });
\ No newline at end of file