From 154ce61a3df51ff0ba0f81e7e9f18dd80e914693 Mon Sep 17 00:00:00 2001
From: Samuel Clay <samuel@ofbrooklyn.com>
Date: Mon, 5 Mar 2012 12:57:47 -0800
Subject: [PATCH 1/3] New audio control, with Flash fallback for browsers like
 Firefox/IE.

---
 assets.yml                           |   1 +
 media/css/reader.css                 |   4 +
 media/flash/audiojs.swf              | Bin 0 -> 1735 bytes
 media/img/reader/player-graphics.gif | Bin 0 -> 4499 bytes
 media/js/audio.js                    | 702 +++++++++++++++++++++++++++
 media/js/newsblur/reader.js          |  16 +-
 utils/story_functions.py             |   2 +-
 7 files changed, 723 insertions(+), 2 deletions(-)
 create mode 100755 media/flash/audiojs.swf
 create mode 100755 media/img/reader/player-graphics.gif
 create mode 100755 media/js/audio.js

diff --git a/assets.yml b/assets.yml
index f5577c18a..18657808e 100644
--- a/assets.yml
+++ b/assets.yml
@@ -50,6 +50,7 @@ javascripts:
         - media/js/jquery.flot.js
         - media/js/jquery.tipsy.js
         - media/js/jquery.chosen.js
+        - media/js/audio.js
         - media/js/socket.io-client.0.8.7.js
         - media/js/inflector.js
         - media/js/underscore.js
diff --git a/media/css/reader.css b/media/css/reader.css
index b0c439b93..ac0c240f2 100644
--- a/media/css/reader.css
+++ b/media/css/reader.css
@@ -1949,6 +1949,10 @@ background: transparent;
     padding: 0;
 }
 
+#story_pane .audiojs audio {
+    display: none;
+}
+
 /* ====================== */
 /* = River Progress Bar = */
 /* ====================== */
diff --git a/media/flash/audiojs.swf b/media/flash/audiojs.swf
new file mode 100755
index 0000000000000000000000000000000000000000..b6b0275ae2c8225c6fe929e42a9c47f8593fe354
GIT binary patch
literal 1735
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

literal 0
HcmV?d00001

diff --git a/media/img/reader/player-graphics.gif b/media/img/reader/player-graphics.gif
new file mode 100755
index 0000000000000000000000000000000000000000..3e4d9d4e512052d49bfa872c37d14f2a1c211b69
GIT binary patch
literal 4499
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
KA7@~Jh5rN$ej<?o

literal 0
HcmV?d00001

diff --git a/media/js/audio.js b/media/js/audio.js
new file mode 100755
index 000000000..aeeefcdbe
--- /dev/null
+++ b/media/js/audio.js
@@ -0,0 +1,702 @@
+// A cross-browser javascript shim for html5 audio
+(function(audiojs, audiojsInstance, container) {
+  // Use the path to the audio.js file to create relative paths to the swf and player graphics
+  // Remember that some systems (e.g. ruby on rails) append strings like '?1301478336' to asset paths
+  var path = (function() {
+    var re = new RegExp('audio(\.min)?\.js.*'),
+        scripts = document.getElementsByTagName('script');
+    for (var i = 0, ii = scripts.length; i < ii; i++) {
+      var path = scripts[i].getAttribute('src');
+      if(re.test(path)) return path.replace(re, '');
+    }
+  })();
+  
+  // ##The audiojs interface
+  // This is the global object which provides an interface for creating new `audiojs` instances.
+  // It also stores all of the construction helper methods and variables.
+  container[audiojs] = {
+    instanceCount: 0,
+    instances: {},
+    // The markup for the swf. It is injected into the page if there is not support for the `<audio>` element. The `$n`s are placeholders.  
+    // `$1` The name of the flash movie  
+    // `$2` The path to the swf  
+    // `$3` Cache invalidation  
+    flashSource: '\
+      <object classid="clsid:D27CDB6E-AE6D-11cf-96B8-444553540000" id="$1" width="1" height="1" name="$1" style="position: absolute; left: -1px;"> \
+        <param name="movie" value="$2?playerInstance='+audiojs+'.instances[\'$1\']&datetime=$3"> \
+        <param name="allowscriptaccess" value="always"> \
+        <embed name="$1" src="$2?playerInstance='+audiojs+'.instances[\'$1\']&datetime=$3" width="1" height="1" allowscriptaccess="always"> \
+      </object>',
+
+    // ### The main settings object
+    // Where all the default settings are stored. Each of these variables and methods can be overwritten by the user-provided `options` object.
+    settings: {
+      autoplay: false,
+      loop: false,
+      preload: true,
+      imageLocation: path + 'player-graphics.gif',
+      swfLocation: path + 'audiojs.swf',
+      useFlash: (function() {
+        var a = document.createElement('audio');
+        return !(a.canPlayType && a.canPlayType('audio/mpeg;').replace(/no/, ''));
+      })(),
+      hasFlash: (function() {
+        if (navigator.plugins && navigator.plugins.length && navigator.plugins['Shockwave Flash']) {
+          return true;
+        } else if (navigator.mimeTypes && navigator.mimeTypes.length) {
+          var mimeType = navigator.mimeTypes['application/x-shockwave-flash'];
+          return mimeType && mimeType.enabledPlugin;
+        } else {
+          try {
+            var ax = new ActiveXObject('ShockwaveFlash.ShockwaveFlash');
+            return true;
+          } catch (e) {}
+        }
+        return false;
+      })(),
+      // The default markup and classes for creating the player:
+      createPlayer: {
+        markup: '\
+          <div class="play-pause"> \
+            <p class="play"></p> \
+            <p class="pause"></p> \
+            <p class="loading"></p> \
+            <p class="error"></p> \
+          </div> \
+          <div class="scrubber"> \
+            <div class="progress"></div> \
+            <div class="loaded"></div> \
+          </div> \
+          <div class="time"> \
+            <em class="played">00:00</em>/<strong class="duration">00:00</strong> \
+          </div> \
+          <div class="error-message"></div>',
+        playPauseClass: 'play-pause',
+        scrubberClass: 'scrubber',
+        progressClass: 'progress',
+        loaderClass: 'loaded',
+        timeClass: 'time',
+        durationClass: 'duration',
+        playedClass: 'played',
+        errorMessageClass: 'error-message',
+        playingClass: 'playing',
+        loadingClass: 'loading',
+        errorClass: 'error'
+      },
+      // The css used by the default player. This is is dynamically injected into a `<style>` tag in the top of the head.
+      css: '\
+        .audiojs audio { position: absolute; left: -1px; } \
+        .audiojs { width: 460px; height: 36px; background: #404040; overflow: hidden; font-family: monospace; font-size: 12px; \
+          background-image: -webkit-gradient(linear, left top, left bottom, color-stop(0, #444), color-stop(0.5, #555), color-stop(0.51, #444), color-stop(1, #444)); \
+          background-image: -moz-linear-gradient(center top, #444 0%, #555 50%, #444 51%, #444 100%); \
+          -webkit-box-shadow: 1px 1px 8px rgba(0, 0, 0, 0.3); -moz-box-shadow: 1px 1px 8px rgba(0, 0, 0, 0.3); \
+          -o-box-shadow: 1px 1px 8px rgba(0, 0, 0, 0.3); box-shadow: 1px 1px 8px rgba(0, 0, 0, 0.3); } \
+        .audiojs .play-pause { width: 25px; height: 40px; padding: 4px 6px; margin: 0px; float: left; overflow: hidden; border-right: 1px solid #000; } \
+        .audiojs p { display: none; width: 25px; height: 40px; margin: 0px; cursor: pointer; } \
+        .audiojs .play { display: block; } \
+        .audiojs .scrubber { position: relative; float: left; width: 280px; background: #5a5a5a; height: 14px; margin: 10px; border-top: 1px solid #3f3f3f; border-left: 0px; border-bottom: 0px; overflow: hidden; } \
+        .audiojs .progress { position: absolute; top: 0px; left: 0px; height: 14px; width: 0px; background: #ccc; z-index: 1; \
+          background-image: -webkit-gradient(linear, left top, left bottom, color-stop(0, #ccc), color-stop(0.5, #ddd), color-stop(0.51, #ccc), color-stop(1, #ccc)); \
+          background-image: -moz-linear-gradient(center top, #ccc 0%, #ddd 50%, #ccc 51%, #ccc 100%); } \
+        .audiojs .loaded { position: absolute; top: 0px; left: 0px; height: 14px; width: 0px; background: #000; \
+          background-image: -webkit-gradient(linear, left top, left bottom, color-stop(0, #222), color-stop(0.5, #333), color-stop(0.51, #222), color-stop(1, #222)); \
+          background-image: -moz-linear-gradient(center top, #222 0%, #333 50%, #222 51%, #222 100%); } \
+        .audiojs .time { float: left; height: 36px; line-height: 36px; margin: 0px 0px 0px 6px; padding: 0px 6px 0px 12px; border-left: 1px solid #000; color: #ddd; text-shadow: 1px 1px 0px rgba(0, 0, 0, 0.5); } \
+        .audiojs .time em { padding: 0px 2px 0px 0px; color: #f9f9f9; font-style: normal; } \
+        .audiojs .time strong { padding: 0px 0px 0px 2px; font-weight: normal; } \
+        .audiojs .error-message { float: left; display: none; margin: 0px 10px; height: 36px; width: 400px; overflow: hidden; line-height: 36px; white-space: nowrap; color: #fff; \
+          text-overflow: ellipsis; -o-text-overflow: ellipsis; -icab-text-overflow: ellipsis; -khtml-text-overflow: ellipsis; -moz-text-overflow: ellipsis; -webkit-text-overflow: ellipsis; } \
+        .audiojs .error-message a { color: #eee; text-decoration: none; padding-bottom: 1px; border-bottom: 1px solid #999; white-space: wrap; } \
+        \
+        .audiojs .play { background: url("$1") -2px -1px no-repeat; } \
+        .audiojs .loading { background: url("$1") -2px -31px no-repeat; } \
+        .audiojs .error { background: url("$1") -2px -61px no-repeat; } \
+        .audiojs .pause { background: url("$1") -2px -91px no-repeat; } \
+        \
+        .playing .play, .playing .loading, .playing .error { display: none; } \
+        .playing .pause { display: block; } \
+        \
+        .loading .play, .loading .pause, .loading .error { display: none; } \
+        .loading .loading { display: block; } \
+        \
+        .error .time, .error .play, .error .pause, .error .scrubber, .error .loading { display: none; } \
+        .error .error { display: block; } \
+        .error .play-pause p { cursor: auto; } \
+        .error .error-message { display: block; }',
+      // The default event callbacks:
+      trackEnded: function(e) {},
+      flashError: function() {
+        var player = this.settings.createPlayer,
+            errorMessage = getByClass(player.errorMessageClass, this.wrapper),
+            html = 'Missing <a href="http://get.adobe.com/flashplayer/">flash player</a> plugin.';
+        if (this.mp3) html += ' <a href="'+this.mp3+'">Download audio file</a>.';
+        container[audiojs].helpers.removeClass(this.wrapper, player.loadingClass);
+        container[audiojs].helpers.addClass(this.wrapper, player.errorClass);
+        errorMessage.innerHTML = html;
+      },
+      loadError: function(e) {
+        var player = this.settings.createPlayer,
+            errorMessage = getByClass(player.errorMessageClass, this.wrapper);
+        container[audiojs].helpers.removeClass(this.wrapper, player.loadingClass);
+        container[audiojs].helpers.addClass(this.wrapper, player.errorClass);
+        errorMessage.innerHTML = 'Error loading: "'+this.mp3+'"';
+      },
+      init: function() {
+        var player = this.settings.createPlayer;
+        container[audiojs].helpers.addClass(this.wrapper, player.loadingClass);
+      },
+      loadStarted: function() {
+        var player = this.settings.createPlayer,
+            duration = getByClass(player.durationClass, this.wrapper),
+            m = Math.floor(this.duration / 60),
+            s = Math.floor(this.duration % 60);
+        container[audiojs].helpers.removeClass(this.wrapper, player.loadingClass);
+        duration.innerHTML = ((m<10?'0':'')+m+':'+(s<10?'0':'')+s);
+      },
+      loadProgress: function(percent) {
+        var player = this.settings.createPlayer,
+            scrubber = getByClass(player.scrubberClass, this.wrapper),
+            loaded = getByClass(player.loaderClass, this.wrapper);
+        loaded.style.width = (scrubber.offsetWidth * percent) + 'px';
+      },
+      playPause: function() {
+        if (this.playing) this.settings.play();
+        else this.settings.pause();
+      },
+      play: function() {
+        var player = this.settings.createPlayer;
+        container[audiojs].helpers.addClass(this.wrapper, player.playingClass);
+      },
+      pause: function() {
+        var player = this.settings.createPlayer;
+        container[audiojs].helpers.removeClass(this.wrapper, player.playingClass);
+      },
+      updatePlayhead: function(percent) {
+        var player = this.settings.createPlayer,
+            scrubber = getByClass(player.scrubberClass, this.wrapper),
+            progress = getByClass(player.progressClass, this.wrapper);
+        progress.style.width = (scrubber.offsetWidth * percent) + 'px';
+
+        var played = getByClass(player.playedClass, this.wrapper),
+            p = this.duration * percent,
+            m = Math.floor(p / 60),
+            s = Math.floor(p % 60);
+        played.innerHTML = ((m<10?'0':'')+m+':'+(s<10?'0':'')+s);
+      }
+    },
+
+    // ### Contructor functions
+
+    // `create()`  
+    // Used to create a single `audiojs` instance.  
+    // If an array is passed then it calls back to `createAll()`.  
+    // Otherwise, it creates a single instance and returns it.  
+    create: function(element, options) {
+      var options = options || {}
+      if (element.length) {
+        return this.createAll(options, element);
+      } else {
+        return this.newInstance(element, options);
+      }
+    },
+
+    // `createAll()`  
+    // Creates multiple `audiojs` instances.  
+    // If `elements` is `null`, then automatically find any `<audio>` tags on the page and create `audiojs` instances for them.
+    createAll: function(options, elements) {
+      var audioElements = elements || document.getElementsByTagName('audio'),
+          instances = []
+          options = options || {};
+      for (var i = 0, ii = audioElements.length; i < ii; i++) {
+        instances.push(this.newInstance(audioElements[i], options));
+      }
+      return instances;
+    },
+
+    // ### Creating and returning a new instance
+    // This goes through all the steps required to build out a usable `audiojs` instance.
+    newInstance: function(element, options) {
+      var element = element,
+          s = this.helpers.clone(this.settings),
+          id = 'audiojs'+this.instanceCount,
+          wrapperId = 'audiojs_wrapper'+this.instanceCount,
+          instanceCount = this.instanceCount++;
+
+      // Check for `autoplay`, `loop` and `preload` attributes and write them into the settings.
+      if (element.getAttribute('autoplay') != null) s.autoplay = true;
+      if (element.getAttribute('loop') != null) s.loop = true;
+      if (element.getAttribute('preload') == 'none') s.preload = false;
+      // Merge the default settings with the user-defined `options`.
+      if (options) this.helpers.merge(s, options);
+
+      // Inject the player html if required.
+      if (s.createPlayer.markup) element = this.createPlayer(element, s.createPlayer, wrapperId);
+      else element.parentNode.setAttribute('id', wrapperId);
+
+      // Return a new `audiojs` instance.
+      var audio = new container[audiojsInstance](element, s);
+
+      // If css has been passed in, dynamically inject it into the `<head>`.
+      if (s.css) this.helpers.injectCss(audio, s.css);
+
+      // If `<audio>` or mp3 playback isn't supported, insert the swf & attach the required events for it.
+      if (s.useFlash && s.hasFlash) {
+        this.injectFlash(audio, id);
+        this.attachFlashEvents(audio.wrapper, audio);
+      } else if (s.useFlash && !s.hasFlash) {
+        this.settings.flashError.apply(audio);
+      }
+
+      // Attach event callbacks to the new audiojs instance.
+      if (!s.useFlash || (s.useFlash && s.hasFlash)) this.attachEvents(audio.wrapper, audio);
+
+      // Store the newly-created `audiojs` instance.
+      this.instances[id] = audio;
+      return audio;
+    },
+
+    // ### Helper methods for constructing a working player
+    // Inject a wrapping div and the markup for the html player.
+    createPlayer: function(element, player, id) {
+      var wrapper = document.createElement('div'),
+          newElement = element.cloneNode(true);
+      wrapper.setAttribute('class', 'audiojs');
+      wrapper.setAttribute('className', 'audiojs');
+      wrapper.setAttribute('id', id);
+
+      // Fix IE's broken implementation of `innerHTML` & `cloneNode` for HTML5 elements.
+      if (newElement.outerHTML && !document.createElement('audio').canPlayType) {
+        newElement = this.helpers.cloneHtml5Node(element);
+        wrapper.innerHTML = player.markup;
+        wrapper.appendChild(newElement);
+        element.outerHTML = wrapper.outerHTML;
+        wrapper = document.getElementById(id);
+      } else {
+        wrapper.appendChild(newElement);
+        wrapper.innerHTML = wrapper.innerHTML + player.markup;
+        element.parentNode.replaceChild(wrapper, element);
+      }
+      return wrapper.getElementsByTagName('audio')[0];
+    },
+
+    // Attaches useful event callbacks to an `audiojs` instance.
+    attachEvents: function(wrapper, audio) {
+      if (!audio.settings.createPlayer) return;
+      var player = audio.settings.createPlayer,
+          playPause = getByClass(player.playPauseClass, wrapper),
+          scrubber = getByClass(player.scrubberClass, wrapper),
+          leftPos = function(elem) {
+            var curleft = 0;
+            if (elem.offsetParent) {
+              do { curleft += elem.offsetLeft; } while (elem = elem.offsetParent);
+            }
+            return curleft;
+          };
+
+      container[audiojs].events.addListener(playPause, 'click', function(e) {
+        audio.playPause.apply(audio);
+      });
+
+      container[audiojs].events.addListener(scrubber, 'click', function(e) {
+        var relativeLeft = e.clientX - leftPos(this);
+        audio.skipTo(relativeLeft / scrubber.offsetWidth);
+      });
+
+      // _If flash is being used, then the following handlers don't need to be registered._
+      if (audio.settings.useFlash) return;
+
+      // Start tracking the load progress of the track.
+      container[audiojs].events.trackLoadProgress(audio);
+
+      container[audiojs].events.addListener(audio.element, 'timeupdate', function(e) {
+        audio.updatePlayhead.apply(audio);
+      });
+
+      container[audiojs].events.addListener(audio.element, 'ended', function(e) {
+        audio.trackEnded.apply(audio);
+      });
+
+      container[audiojs].events.addListener(audio.source, 'error', function(e) {
+        // on error, cancel any load timers that are running.
+        clearInterval(audio.readyTimer);
+        clearInterval(audio.loadTimer);
+        audio.settings.loadError.apply(audio);
+      });
+
+    },
+
+    // Flash requires a slightly different API to the `<audio>` element, so this method is used to overwrite the standard event handlers.
+    attachFlashEvents: function(element, audio) {
+      audio['swfReady'] = false;
+      audio['load'] = function(mp3) {
+        // If the swf isn't ready yet then just set `audio.mp3`. `init()` will load it in once the swf is ready.
+        audio.mp3 = mp3;
+        if (audio.swfReady) audio.element.load(mp3);
+      }
+      audio['loadProgress'] = function(percent, duration) {
+        audio.loadedPercent = percent;
+        audio.duration = duration;
+        audio.settings.loadStarted.apply(audio);
+        audio.settings.loadProgress.apply(audio, [percent]);
+      }
+      audio['skipTo'] = function(percent) {
+        if (percent > audio.loadedPercent) return;
+        audio.updatePlayhead.call(audio, [percent])
+        audio.element.skipTo(percent);
+      }
+      audio['updatePlayhead'] = function(percent) {
+        audio.settings.updatePlayhead.apply(audio, [percent]);
+      }
+      audio['play'] = function() {
+        // If the audio hasn't started preloading, then start it now.  
+        // Then set `preload` to `true`, so that any tracks loaded in subsequently are loaded straight away.
+        if (!audio.settings.preload) {
+          audio.settings.preload = true;
+          audio.element.init(audio.mp3);
+        }
+        audio.playing = true;
+        // IE doesn't allow a method named `play()` to be exposed through `ExternalInterface`, so lets go with `pplay()`.  
+        // <http://dev.nuclearrooster.com/2008/07/27/externalinterfaceaddcallback-can-cause-ie-js-errors-with-certain-keyworkds/>
+        audio.element.pplay();
+        audio.settings.play.apply(audio);
+      }
+      audio['pause'] = function() {
+        audio.playing = false;
+        // Use `ppause()` for consistency with `pplay()`, even though it isn't really required.
+        audio.element.ppause();
+        audio.settings.pause.apply(audio);
+      }
+      audio['setVolume'] = function(v) {
+        audio.element.setVolume(v);
+      }
+      audio['loadStarted'] = function() {
+        // Load the mp3 specified by the audio element into the swf.
+        audio.swfReady = true;
+        if (audio.settings.preload) audio.element.init(audio.mp3);
+        if (audio.settings.autoplay) audio.play.apply(audio);
+      }
+    },
+
+    // ### Injecting an swf from a string
+    // Build up the swf source by replacing the `$keys` and then inject the markup into the page.
+    injectFlash: function(audio, id) {
+      var flashSource = this.flashSource.replace(/\$1/g, id);
+      flashSource = flashSource.replace(/\$2/g, audio.settings.swfLocation);
+      // `(+new Date)` ensures the swf is not pulled out of cache. The fixes an issue with Firefox running multiple players on the same page.
+      flashSource = flashSource.replace(/\$3/g, (+new Date + Math.random()));
+      // Inject the player markup using a more verbose `innerHTML` insertion technique that works with IE.
+      var html = audio.wrapper.innerHTML,
+          div = document.createElement('div');
+      div.innerHTML = flashSource + html;
+      audio.wrapper.innerHTML = div.innerHTML;
+      audio.element = this.helpers.getSwf(id);
+    },
+
+    // ## Helper functions
+    helpers: {
+      // **Merge two objects, with `obj2` overwriting `obj1`**  
+      // The merge is shallow, but that's all that is required for our purposes.
+      merge: function(obj1, obj2) {
+        for (attr in obj2) {
+          if (obj1.hasOwnProperty(attr) || obj2.hasOwnProperty(attr)) {
+            obj1[attr] = obj2[attr];
+          }
+        }
+      },
+      // **Clone a javascript object (recursively)**
+      clone: function(obj){
+        if (obj == null || typeof(obj) !== 'object') return obj;
+        var temp = new obj.constructor();
+        for (var key in obj) temp[key] = arguments.callee(obj[key]);
+        return temp;
+      },
+      // **Adding/removing classnames from elements**
+      addClass: function(element, className) {
+        var re = new RegExp('(\\s|^)'+className+'(\\s|$)');
+        if (re.test(element.className)) return;
+        element.className += ' ' + className;
+      },
+      removeClass: function(element, className) {
+        var re = new RegExp('(\\s|^)'+className+'(\\s|$)');
+        element.className = element.className.replace(re,' ');
+      },
+      // **Dynamic CSS injection**  
+      // Takes a string of css, inserts it into a `<style>`, then injects it in at the very top of the `<head>`. This ensures any user-defined styles will take precedence.
+      injectCss: function(audio, string) {
+        // If an `audiojs` `<style>` tag already exists, then append to it rather than creating a whole new `<style>`.
+        var prepend = '',
+            styles = document.getElementsByTagName('style'),
+            css = string.replace(/\$1/g, audio.settings.imageLocation);
+
+        for (var i = 0, ii = styles.length; i < ii; i++) {
+          var title = styles[i].getAttribute('title');
+          if (title && ~title.indexOf('audiojs')) {
+            style = styles[i];
+            if (style.innerHTML === css) return;
+            prepend = style.innerHTML;
+            break;
+          }
+        };
+
+        var head = document.getElementsByTagName('head')[0],
+            firstchild = head.firstChild,
+            style = document.createElement('style');
+
+        if (!head) return;
+
+        style.setAttribute('type', 'text/css');
+        style.setAttribute('title', 'audiojs');
+
+        if (style.styleSheet) style.styleSheet.cssText = prepend + css;
+        else style.appendChild(document.createTextNode(prepend + css));
+
+        if (firstchild) head.insertBefore(style, firstchild);
+        else head.appendChild(styleElement);
+      },
+      // **Handle all the IE6+7 requirements for cloning `<audio>` nodes**  
+      // Create a html5-safe document fragment by injecting an `<audio>` element into the document fragment.
+      cloneHtml5Node: function(audioTag) {
+        var fragment = document.createDocumentFragment(),
+            doc = fragment.createElement ? fragment : document;
+        doc.createElement('audio');
+        var div = doc.createElement('div');
+        fragment.appendChild(div);
+        div.innerHTML = audioTag.outerHTML;
+        return div.firstChild;
+      },
+      // **Cross-browser `<object>` / `<embed>` element selection**
+      getSwf: function(name) {
+        var swf = document[name] || window[name];
+        return swf.length > 1 ? swf[swf.length - 1] : swf;
+      }
+    },
+    // ## Event-handling
+    events: {
+      memoryLeaking: false,
+      listeners: [],
+      // **A simple cross-browser event handler abstraction**
+      addListener: function(element, eventName, func) {
+        // For modern browsers use the standard DOM-compliant `addEventListener`.
+        if (element.addEventListener) {
+          element.addEventListener(eventName, func, false);
+          // For older versions of Internet Explorer, use `attachEvent`.  
+          // Also provide a fix for scoping `this` to the calling element and register each listener so the containing elements can be purged on page unload.
+        } else if (element.attachEvent) {
+          this.listeners.push(element);
+          if (!this.memoryLeaking) {
+            window.attachEvent('onunload', function() {
+              if(this.listeners) {
+                for (var i = 0, ii = this.listeners.length; i < ii; i++) {
+                  container[audiojs].events.purge(this.listeners[i]);
+                }
+              }
+            });
+            this.memoryLeaking = true;
+          }
+          element.attachEvent('on' + eventName, function() {
+            func.call(element, window.event);
+          });
+        }
+      },
+
+      trackLoadProgress: function(audio) {
+        // If `preload` has been set to `none`, then we don't want to start loading the track yet.
+        if (!audio.settings.preload) return;
+
+        var readyTimer,
+            loadTimer,
+            audio = audio,
+            ios = (/(ipod|iphone|ipad)/i).test(navigator.userAgent);
+
+        // Use timers here rather than the official `progress` event, as Chrome has issues calling `progress` when loading mp3 files from cache.
+        readyTimer = setInterval(function() {
+          if (audio.element.readyState > -1) {
+            // iOS doesn't start preloading the mp3 until the user interacts manually, so this stops the loader being displayed prematurely.
+            if (!ios) audio.init.apply(audio);
+          }
+          if (audio.element.readyState > 1) {
+            if (audio.settings.autoplay) audio.play.apply(audio);
+            clearInterval(readyTimer);
+            // Once we have data, start tracking the load progress.
+            loadTimer = setInterval(function() {
+              audio.loadProgress.apply(audio);
+              if (audio.loadedPercent >= 1) clearInterval(loadTimer);
+            });
+          }
+        }, 10);
+        audio.readyTimer = readyTimer;
+        audio.loadTimer = loadTimer;
+      },
+
+      // **Douglas Crockford's IE6 memory leak fix**  
+      // <http://javascript.crockford.com/memory/leak.html>  
+      // This is used to release the memory leak created by the circular references created when fixing `this` scoping for IE. It is called on page unload.
+      purge: function(d) {
+        var a = d.attributes, i;
+        if (a) {
+          for (i = 0; i < a.length; i += 1) {
+            if (typeof d[a[i].name] === 'function') d[a[i].name] = null;
+          }
+        }
+        a = d.childNodes;
+        if (a) {
+          for (i = 0; i < a.length; i += 1) purge(d.childNodes[i]);
+        }
+      },
+
+      // **DOMready function**  
+      // As seen here: <https://github.com/dperini/ContentLoaded/>.
+      ready: (function() { return function(fn) {
+        var win = window, done = false, top = true,
+        doc = win.document, root = doc.documentElement,
+        add = doc.addEventListener ? 'addEventListener' : 'attachEvent',
+        rem = doc.addEventListener ? 'removeEventListener' : 'detachEvent',
+        pre = doc.addEventListener ? '' : 'on',
+        init = function(e) {
+          if (e.type == 'readystatechange' && doc.readyState != 'complete') return;
+          (e.type == 'load' ? win : doc)[rem](pre + e.type, init, false);
+          if (!done && (done = true)) fn.call(win, e.type || e);
+        },
+        poll = function() {
+          try { root.doScroll('left'); } catch(e) { setTimeout(poll, 50); return; }
+          init('poll');
+        };
+        if (doc.readyState == 'complete') fn.call(win, 'lazy');
+        else {
+          if (doc.createEventObject && root.doScroll) {
+            try { top = !win.frameElement; } catch(e) { }
+            if (top) poll();
+          }
+          doc[add](pre + 'DOMContentLoaded', init, false);
+          doc[add](pre + 'readystatechange', init, false);
+          win[add](pre + 'load', init, false);
+        }
+      }
+      })()
+
+    }
+  }
+
+  // ## The audiojs class
+  // We create one of these per `<audio>` and then push them into `audiojs['instances']`.
+  container[audiojsInstance] = function(element, settings) {
+    // Each audio instance returns an object which contains an API back into the `<audio>` element.
+    this.element = element;
+    this.wrapper = element.parentNode;
+    this.source = element.getElementsByTagName('source')[0] || element;
+    // First check the `<audio>` element directly for a src and if one is not found, look for a `<source>` element.
+    this.mp3 = (function(element) {
+      var source = element.getElementsByTagName('source')[0];
+      return element.getAttribute('src') || (source ? source.getAttribute('src') : null);
+    })(element);
+    this.settings = settings;
+    this.loadStartedCalled = false;
+    this.loadedPercent = 0;
+    this.duration = 1;
+    this.playing = false;
+  }
+
+  container[audiojsInstance].prototype = {
+    // API access events:
+    // Each of these do what they need do and then call the matching methods defined in the settings object.
+    updatePlayhead: function() {
+      var percent = this.element.currentTime / this.duration;
+      this.settings.updatePlayhead.apply(this, [percent]);
+    },
+    skipTo: function(percent) {
+      if (percent > this.loadedPercent) return;
+      this.element.currentTime = this.duration * percent;
+      this.updatePlayhead();
+    },
+    load: function(mp3) {
+      this.loadStartedCalled = false;
+      this.source.setAttribute('src', mp3);
+      // The now outdated `load()` method is required for Safari 4
+      this.element.load();
+      this.mp3 = mp3;
+      container[audiojs].events.trackLoadProgress(this);
+    },
+    loadError: function() {
+      this.settings.loadError.apply(this);
+    },
+    init: function() {
+      this.settings.init.apply(this);
+    },
+    loadStarted: function() {
+      // Wait until `element.duration` exists before setting up the audio player.
+      if (!this.element.duration) return false;
+
+      this.duration = this.element.duration;
+      this.updatePlayhead();
+      this.settings.loadStarted.apply(this);
+    },
+    loadProgress: function() {
+      if (this.element.buffered != null && this.element.buffered.length) {
+        // Ensure `loadStarted()` is only called once.
+        if (!this.loadStartedCalled) {
+          this.loadStartedCalled = this.loadStarted();
+        }
+        var durationLoaded = this.element.buffered.end(this.element.buffered.length - 1);
+        this.loadedPercent = durationLoaded / this.duration;
+
+        this.settings.loadProgress.apply(this, [this.loadedPercent]);
+      }
+    },
+    playPause: function() {
+      if (this.playing) this.pause();
+      else this.play();
+    },
+    play: function() {
+      var ios = (/(ipod|iphone|ipad)/i).test(navigator.userAgent);
+      // On iOS this interaction will trigger loading the mp3, so run `init()`.
+      if (ios && this.element.readyState == 0) this.init.apply(this);
+      // If the audio hasn't started preloading, then start it now.  
+      // Then set `preload` to `true`, so that any tracks loaded in subsequently are loaded straight away.
+      if (!this.settings.preload) {
+        this.settings.preload = true;
+        this.element.setAttribute('preload', 'auto');
+        container[audiojs].events.trackLoadProgress(this);
+      }
+      this.playing = true;
+      this.element.play();
+      this.settings.play.apply(this);
+    },
+    pause: function() {
+      this.playing = false;
+      this.element.pause();
+      this.settings.pause.apply(this);
+    },
+    setVolume: function(v) {
+      this.element.volume = v;
+    },
+    trackEnded: function(e) {
+      this.skipTo.apply(this, [0]);
+      if (!this.settings.loop) this.pause.apply(this);
+      this.settings.trackEnded.apply(this);
+    }
+  }
+
+  // **getElementsByClassName**  
+  // Having to rely on `getElementsByTagName` is pretty inflexible internally, so a modified version of Dustin Diaz's `getElementsByClassName` has been included.
+  // This version cleans things up and prefers the native DOM method if it's available.
+  var getByClass = function(searchClass, node) {
+    var matches = [];
+    node = node || document;
+
+    if (node.getElementsByClassName) {
+      matches = node.getElementsByClassName(searchClass);
+    } else {
+      var i, l, 
+          els = node.getElementsByTagName("*"),
+          pattern = new RegExp("(^|\\s)"+searchClass+"(\\s|$)");
+
+      for (i = 0, l = els.length; i < l; i++) {
+        if (pattern.test(els[i].className)) {
+          matches.push(els[i]);
+        }
+      }
+    }
+    return matches.length > 1 ? matches : matches[0];
+  };
+// The global variable names are passed in here and can be changed if they conflict with anything else.
+})('audiojs', 'audiojsInstance', this);
\ No newline at end of file
diff --git a/media/js/newsblur/reader.js b/media/js/newsblur/reader.js
index b0d4f35ad..1742fa130 100644
--- a/media/js/newsblur/reader.js
+++ b/media/js/newsblur/reader.js
@@ -3682,6 +3682,7 @@
             
             this.append_feed_view_story_endbar();
             this.hover_story_feed_titles();
+            this.attach_audio_handler_to_stories();
             if (first_load) this.show_stories_preference_in_feed_view(true);
         },
         
@@ -3742,7 +3743,20 @@
             });
         },
         
-
+        attach_audio_handler_to_stories: function() {
+            var $audio = $('audio', this.$s.$feed_stories).filter(function() {
+                return !$(this).closest('.audiojs').length;
+            });
+            var audio_opts = window.a = {
+                imageLocation: NEWSBLUR.Globals.MEDIA_URL + 'img/reader/player-graphics.gif',
+                swfLocation: NEWSBLUR.Globals.MEDIA_URL + 'flash/audiojs.swf',
+                preload: false
+            };
+            console.log(["audio", $audio, audio_opts]);
+            audiojs.events.ready(function() {
+                audiojs.createAll(audio_opts, $audio);
+            });
+        },
         
         preserve_classifier_color: function($story, classifier_type, value, score) {
             var $t;
diff --git a/utils/story_functions.py b/utils/story_functions.py
index 621114de9..00662941a 100644
--- a/utils/story_functions.py
+++ b/utils/story_functions.py
@@ -83,7 +83,7 @@ def pre_process_story(entry):
             media_type_name = media_type.split('/')[0]
             if 'audio' in media_type and media_url:
                 entry['story_content'] += """<br><br>
-                    <audio controls="controls">
+                    <audio controls="controls" preload="none">
                         <source src="%(media_url)s" type="%(media_type)s" />
                     </audio>"""  % {
                         'media_url': media_url, 

From 33fa13cf69d477e3f508645a258ea3a8141860f1 Mon Sep 17 00:00:00 2001
From: Samuel Clay <samuel@ofbrooklyn.com>
Date: Mon, 5 Mar 2012 13:12:50 -0800
Subject: [PATCH 2/3] Fixing issue around feeds that are mistakenly declared as
 not having a page.

---
 apps/rss_feeds/models.py    | 1 +
 media/js/newsblur/reader.js | 2 +-
 utils/feed_fetcher.py       | 1 +
 3 files changed, 3 insertions(+), 1 deletion(-)

diff --git a/apps/rss_feeds/models.py b/apps/rss_feeds/models.py
index 78809ef10..ebdd0f9b4 100644
--- a/apps/rss_feeds/models.py
+++ b/apps/rss_feeds/models.py
@@ -327,6 +327,7 @@ class Feed(models.Model):
             self.count_errors_in_history('page', status_code)
         elif self.has_page_exception:
             self.has_page_exception = False
+            self.has_page = True
             self.active = True
             self.save()
         
diff --git a/media/js/newsblur/reader.js b/media/js/newsblur/reader.js
index 1742fa130..4504587c7 100644
--- a/media/js/newsblur/reader.js
+++ b/media/js/newsblur/reader.js
@@ -3752,7 +3752,7 @@
                 swfLocation: NEWSBLUR.Globals.MEDIA_URL + 'flash/audiojs.swf',
                 preload: false
             };
-            console.log(["audio", $audio, audio_opts]);
+
             audiojs.events.ready(function() {
                 audiojs.createAll(audio_opts, $audio);
             });
diff --git a/utils/feed_fetcher.py b/utils/feed_fetcher.py
index c8d94ea49..5f015638f 100644
--- a/utils/feed_fetcher.py
+++ b/utils/feed_fetcher.py
@@ -347,6 +347,7 @@ class Dispatcher:
             
             feed = self.refresh_feed(feed_id)
             if ((self.options['force']) or 
+                (random.random() > .9) or
                 (fetched_feed and
                  feed.feed_link and
                  feed.has_page and

From 13f8ab07fbd4f3ddf2ab66b9a242fec64819b12b Mon Sep 17 00:00:00 2001
From: Samuel Clay <samuel@ofbrooklyn.com>
Date: Mon, 5 Mar 2012 16:28:19 -0800
Subject: [PATCH 3/3] Adding Cuk.ch story about NewsBlur.

---
 templates/static/press.xhtml | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/templates/static/press.xhtml b/templates/static/press.xhtml
index efb0b11a5..4c89e57aa 100644
--- a/templates/static/press.xhtml
+++ b/templates/static/press.xhtml
@@ -76,6 +76,14 @@
           <span class="NB-press-author">Nathan Willis</span>, 
           <span class="NB-press-date">Nov 23, 2011</span>
         </li>
+        <li>
+          <a href="http://www.cuk.ch/articles/5073">NewsBlur: un remplacement de Google Reader?</a>
+          <span class="NB-press-publisher">
+            <img src="http://www.cuk.ch/favicon.gif">
+            Cuk.ch</span>, 
+          <span class="NB-press-author">Sébastien Pennec</span>, 
+          <span class="NB-press-date">Mar 6, 2012</span>
+        </li>
         <li>
           <a href="http://thenextweb.com/apps/2010/08/11/newsblur-intelligently-makes-sense-out-of-your-news-feeds/">NewsBlur is a slick, new RSS reader that intelligently makes sense out of your feeds.</a>
           <span class="NB-press-publisher"><img src="http://thenextweb.com/favicon.ico"> The Next Web</span>, <span class="NB-press-author">Jeff Cormier</span>, <span class="NB-press-date">Nov 08, 2010</span>