ns-styleguide 1.0.0

data/templates/project/libs/foundation/foundation.tooltips.js

@@ -0,0 +1,200 @@
+/*jslint unparam: true, browser: true, indent: 2 */
+
+;(function ($, window, document, undefined) {
+  'use strict';
+
+  Foundation.libs.tooltips = {
+    name: 'tooltips',
+
+    version : '4.1.3',
+
+    settings : {
+      selector : '.has-tip',
+      additionalInheritableClasses : [],
+      tooltipClass : '.tooltip',
+      appendTo: 'body',
+      tipTemplate : function (selector, content) {
+        return '<span data-selector="' + selector + '" class="' 
+          + Foundation.libs.tooltips.settings.tooltipClass.substring(1) 
+          + '">' + content + '<span class="nub"></span></span>';
+      }
+    },
+
+    cache : {},
+
+    init : function (scope, method, options) {
+      var self = this;
+      this.scope = scope || this.scope;
+
+      if (typeof method === 'object') {
+        $.extend(true, this.settings, method);
+      }
+
+      if (typeof method != 'string') {
+        if (Modernizr.touch) {
+          $(this.scope)
+            .on('click.fndtn.tooltip touchstart.fndtn.tooltip touchend.fndtn.tooltip', 
+              '[data-tooltip]', function (e) {
+              e.preventDefault();
+              $(self.settings.tooltipClass).hide();
+              self.showOrCreateTip($(this));
+            })
+            .on('click.fndtn.tooltip touchstart.fndtn.tooltip touchend.fndtn.tooltip', 
+              this.settings.tooltipClass, function (e) {
+              e.preventDefault();
+              $(this).fadeOut(150);
+            });
+        } else {
+          $(this.scope)
+            .on('mouseenter.fndtn.tooltip mouseleave.fndtn.tooltip', 
+              '[data-tooltip]', function (e) {
+              var $this = $(this);
+
+              if (e.type === 'mouseover' || e.type === 'mouseenter') {
+                self.showOrCreateTip($this);
+              } else if (e.type === 'mouseout' || e.type === 'mouseleave') {
+                self.hide($this);
+              }
+            });
+        }
+
+        // $(this.scope).data('fndtn-tooltips', true);
+      } else {
+        return this[method].call(this, options);
+      }
+
+    },
+
+    showOrCreateTip : function ($target) {
+      var $tip = this.getTip($target);
+
+      if ($tip && $tip.length > 0) {
+        return this.show($target);
+      }
+
+      return this.create($target);
+    },
+
+    getTip : function ($target) {
+      var selector = this.selector($target),
+          tip = null;
+
+      if (selector) {
+        tip = $('span[data-selector=' + selector + ']' + this.settings.tooltipClass);
+      }
+
+      return (typeof tip === 'object') ? tip : false;
+    },
+
+    selector : function ($target) {
+      var id = $target.attr('id'),
+          dataSelector = $target.attr('data-tooltip') || $target.attr('data-selector');
+
+      if ((id && id.length < 1 || !id) && typeof dataSelector != 'string') {
+        dataSelector = 'tooltip' + Math.random().toString(36).substring(7);
+        $target.attr('data-selector', dataSelector);
+      }
+
+      return (id && id.length > 0) ? id : dataSelector;
+    },
+
+    create : function ($target) {
+      var $tip = $(this.settings.tipTemplate(this.selector($target), $('<div></div>').html($target.attr('title')).html())),
+          classes = this.inheritable_classes($target);
+
+      $tip.addClass(classes).appendTo(this.settings.appendTo);
+      if (Modernizr.touch) {
+        $tip.append('<span class="tap-to-close">tap to close </span>');
+      }
+      $target.removeAttr('title').attr('title','');
+      this.show($target);
+    },
+
+    reposition : function (target, tip, classes) {
+      var width, nub, nubHeight, nubWidth, column, objPos;
+
+      tip.css('visibility', 'hidden').show();
+
+      width = target.data('width');
+      nub = tip.children('.nub');
+      nubHeight = this.outerHeight(nub);
+      nubWidth = this.outerHeight(nub);
+
+      objPos = function (obj, top, right, bottom, left, width) {
+        return obj.css({
+          'top' : (top) ? top : 'auto',
+          'bottom' : (bottom) ? bottom : 'auto',
+          'left' : (left) ? left : 'auto',
+          'right' : (right) ? right : 'auto',
+          'width' : (width) ? width : 'auto'
+        }).end();
+      };
+
+      objPos(tip, (target.offset().top + this.outerHeight(target) + 10), 'auto', 'auto', target.offset().left, width);
+
+      if ($(window).width() < 767) {
+        objPos(tip, (target.offset().top + this.outerHeight(target) + 10), 'auto', 'auto', 12.5, $(this.scope).width());
+        tip.addClass('tip-override');
+        objPos(nub, -nubHeight, 'auto', 'auto', target.offset().left);
+      } else {
+        var left = target.offset().left;
+        if (Foundation.rtl) {
+          left = target.offset().left + target.offset().width - this.outerWidth(tip);
+        }
+        objPos(tip, (target.offset().top + this.outerHeight(target) + 10), 'auto', 'auto', left, width);
+        tip.removeClass('tip-override');
+        if (classes && classes.indexOf('tip-top') > -1) {
+          objPos(tip, (target.offset().top - this.outerHeight(tip)), 'auto', 'auto', left, width)
+            .removeClass('tip-override');
+        } else if (classes && classes.indexOf('tip-left') > -1) {
+          objPos(tip, (target.offset().top + (this.outerHeight(target) / 2) - nubHeight*2.5), 'auto', 'auto', (target.offset().left - this.outerWidth(tip) - nubHeight), width)
+            .removeClass('tip-override');
+        } else if (classes && classes.indexOf('tip-right') > -1) {
+          objPos(tip, (target.offset().top + (this.outerHeight(target) / 2) - nubHeight*2.5), 'auto', 'auto', (target.offset().left + this.outerWidth(target) + nubHeight), width)
+            .removeClass('tip-override');
+        }
+      }
+
+      tip.css('visibility', 'visible').hide();
+    },
+
+    inheritable_classes : function (target) {
+      var inheritables = ['tip-top', 'tip-left', 'tip-bottom', 'tip-right', 'noradius'].concat(this.settings.additionalInheritableClasses),
+          classes = target.attr('class'),
+          filtered = classes ? $.map(classes.split(' '), function (el, i) {
+            if ($.inArray(el, inheritables) !== -1) {
+              return el;
+            }
+          }).join(' ') : '';
+
+      return $.trim(filtered);
+    },
+
+    show : function ($target) {
+      var $tip = this.getTip($target);
+
+      this.reposition($target, $tip, $target.attr('class'));
+      $tip.fadeIn(150);
+    },
+
+    hide : function ($target) {
+      var $tip = this.getTip($target);
+
+      $tip.fadeOut(150);
+    },
+
+    // deprecate reload
+    reload : function () {
+      var $self = $(this);
+
+      return ($self.data('fndtn-tooltips')) ? $self.foundationTooltips('destroy').foundationTooltips('init') : $self.foundationTooltips('init');
+    },
+
+    off : function () {
+      $(this.scope).off('.fndtn.tooltip');
+      $(this.settings.tooltipClass).each(function (i) {
+        $('[data-tooltip]').get(i).attr('title', $(this).text());
+      }).remove();
+    }
+  };
+}(Foundation.zj, this, this.document));

data/templates/project/libs/foundation/foundation.topbar.js

@@ -0,0 +1,245 @@
+/*jslint unparam: true, browser: true, indent: 2 */
+
+;(function ($, window, document, undefined) {
+  'use strict';
+
+  Foundation.libs.topbar = {
+    name : 'topbar',
+
+    version : '4.1.2',
+
+    settings : {
+      index : 0,
+      stickyClass : 'sticky',
+      custom_back_text: true,
+      back_text: 'Back',
+      init : false
+    },
+
+    init : function (section, method, options) {
+      var self = this;
+
+      if (typeof method === 'object') {
+        $.extend(true, this.settings, method);
+      }
+
+      if (typeof method != 'string') {
+
+        $('.top-bar').each(function () {
+          self.settings.$w = $(window);
+          self.settings.$topbar = $(this);
+          self.settings.$section = self.settings.$topbar.find('section');
+          self.settings.$titlebar = self.settings.$topbar.children('ul').first();
+
+
+          self.settings.$topbar.data('index', 0);
+
+          var breakpoint = $("<div class='top-bar-js-breakpoint'/>").insertAfter(self.settings.$topbar);
+          self.settings.breakPoint = breakpoint.width();
+          breakpoint.remove();
+
+          self.assemble();
+
+          if (self.settings.$topbar.parent().hasClass('fixed')) {
+            $('body').css('padding-top', self.outerHeight(self.settings.$topbar));
+          }
+        });
+
+        if (!self.settings.init) {
+          this.events();
+        }
+
+        return this.settings.init;
+      } else {
+        // fire method
+        return this[method].call(this, options);
+      }
+    },
+
+    events : function () {
+      var self = this;
+      var offst = this.outerHeight($('.top-bar'));
+      $(this.scope)
+        .on('click.fndtn.topbar', '.top-bar .toggle-topbar', function (e) {
+          var topbar = $(this).closest('.top-bar'),
+              section = topbar.find('section, .section'),
+              titlebar = topbar.children('ul').first();
+
+          if (!topbar.data('height')) self.largestUL();
+
+          e.preventDefault();
+
+          if (self.breakpoint()) {
+            topbar
+              .toggleClass('expanded')
+              .css('min-height', '');
+          }
+
+          if (!topbar.hasClass('expanded')) {
+            if (!self.rtl) {
+              section.css({left: '0%'});
+              section.find('>.name').css({left: '100%'});
+            } else {
+              section.css({right: '0%'});
+              section.find('>.name').css({right: '100%'});
+            }
+            section.find('li.moved').removeClass('moved');
+            topbar.data('index', 0);
+
+            if (topbar.hasClass('fixed')) {
+              topbar.parent().addClass('fixed');
+              topbar.removeClass('fixed');
+              $('body').css('padding-top',offst);
+            }
+          } else if (topbar.parent().hasClass('fixed')) {
+            topbar.parent().removeClass('fixed');
+            topbar.addClass('fixed');
+            $('body').css('padding-top','0');
+            window.scrollTo(0,0);
+          }
+        })
+
+        .on('click.fndtn.topbar', '.top-bar .has-dropdown>a', function (e) {
+          var topbar = $(this).closest('.top-bar'),
+              section = topbar.find('section, .section'),
+              titlebar = topbar.children('ul').first(),
+              dropdownHeight = $(this).next('.dropdown').outerHeight();
+
+          if (Modernizr.touch || self.breakpoint()) {
+            e.preventDefault();
+          }
+
+          if (self.breakpoint()) {
+            var $this = $(this),
+                $selectedLi = $this.closest('li');
+
+            topbar.data('index', topbar.data('index') + 1);
+            $selectedLi.addClass('moved');
+            if (!self.rtl) {
+              section.css({left: -(100 * topbar.data('index')) + '%'});
+              section.find('>.name').css({left: 100 * topbar.data('index') + '%'});
+            } else {
+              section.css({right: -(100 * topbar.data('index')) + '%'});
+              section.find('>.name').css({right: 100 * topbar.data('index') + '%'});
+            }
+
+            $('.top-bar').css('min-height', dropdownHeight);
+
+            $this.siblings('ul')
+              .height(topbar.data('height') + self.outerHeight(titlebar, true));
+            topbar
+              .css('min-height', topbar.data('height') + self.outerHeight(titlebar, true) * 2)
+          }
+        });
+
+      $(window).on('resize.fndtn.topbar', function () {
+        if (!self.breakpoint()) {
+          $('.top-bar')
+            .css('min-height', '')
+            .removeClass('expanded');
+        }
+      }.bind(this));
+
+      // Go up a level on Click
+      $(this.scope).on('click.fndtn', '.top-bar .has-dropdown .back', function (e) {
+        e.preventDefault();
+
+        var $this = $(this),
+            topbar = $this.closest('.top-bar'),
+            section = topbar.find('section, .section'),
+            $movedLi = $this.closest('li.moved'),
+            $previousLevelUl = $movedLi.parent();
+
+        topbar.data('index', topbar.data('index') - 1);
+        if (!self.rtl) {
+          section.css({left: -(100 * topbar.data('index')) + '%'});
+          section.find('>.name').css({left: 100 * topbar.data('index') + '%'});
+        } else {
+          section.css({right: -(100 * topbar.data('index')) + '%'});
+          section.find('>.name').css({right: 100 * topbar.data('index') + '%'});
+        }
+
+        if (topbar.data('index') === 0) {
+          topbar.css('min-height', 0);
+        }
+
+        setTimeout(function () {
+          $movedLi.removeClass('moved');
+        }, 300);
+      });
+    },
+
+    breakpoint : function () {
+      return $(window).width() <= this.settings.breakPoint || $('html').hasClass('lt-ie9');
+    },
+
+    assemble : function () {
+      var self = this;
+      // Pull element out of the DOM for manipulation
+      this.settings.$section.detach();
+
+      this.settings.$section.find('.has-dropdown>a').each(function () {
+        var $link = $(this),
+            $dropdown = $link.siblings('.dropdown'),
+            $titleLi = $('<li class="title back js-generated"><h5><a href="#"></a></h5></li>');
+
+        // Copy link to subnav
+        if (self.settings.custom_back_text == true) {
+          $titleLi.find('h5>a').html('&laquo; ' + self.settings.back_text);
+        } else {
+          $titleLi.find('h5>a').html('&laquo; ' + $link.html());
+        }
+        $dropdown.prepend($titleLi);
+      });
+
+      // Put element back in the DOM
+      this.settings.$section.appendTo(this.settings.$topbar);
+
+      // check for sticky
+      this.sticky();
+    },
+
+    largestUL : function () {
+      var uls = this.settings.$topbar.find('section ul ul'),
+          largest = uls.first(),
+          total = 0,
+          self = this;
+
+      uls.each(function () {
+        if ($(this).children('li').length > largest.children('li').length) {
+          largest = $(this);
+        }
+      });
+
+      largest.children('li').each(function () { total += self.outerHeight($(this), true); });
+
+      this.settings.$topbar.data('height', total);
+    },
+
+    sticky : function () {
+      var klass = '.' + this.settings.stickyClass;
+      if ($(klass).length > 0) {
+        var distance = $(klass).length ? $(klass).offset().top: 0,
+            $window = $(window);
+            var offst = this.outerHeight($('.top-bar'));
+
+          $window.scroll(function() {
+            if ($window.scrollTop() >= (distance)) {
+              $(klass).addClass("fixed");
+              $('body').css('padding-top',offst);
+            }
+
+            else if ($window.scrollTop() < distance) {
+              $(klass).removeClass("fixed");
+              $('body').css('padding-top','0');
+            }
+        });
+      }
+    },
+
+    off : function () {
+      $(this.scope).off('.fndtn.topbar');
+      $(window).off('.fndtn.topbar');
+    }
+  };
+}(Foundation.zj, this, this.document));

data/templates/project/libs/hello.coffee

@@ -0,0 +1 @@
+console.log "'Allo from CoffeeScript!"

data/templates/project/libs/helper.js

@@ -0,0 +1,385 @@
+/**
+ * MBP - Mobile boilerplate helper functions
+ */
+
+(function(document) {
+
+    window.MBP = window.MBP || {};
+
+    /**
+     * Fix for iPhone viewport scale bug
+     * http://www.blog.highub.com/mobile-2/a-fix-for-iphone-viewport-scale-bug/
+     */
+
+    MBP.viewportmeta = document.querySelector && document.querySelector('meta[name="viewport"]');
+    MBP.ua = navigator.userAgent;
+
+    MBP.scaleFix = function() {
+        if (MBP.viewportmeta && /iPhone|iPad|iPod/.test(MBP.ua) && !/Opera Mini/.test(MBP.ua)) {
+            MBP.viewportmeta.content = 'width=device-width, minimum-scale=1.0, maximum-scale=1.0';
+            document.addEventListener('gesturestart', MBP.gestureStart, false);
+        }
+    };
+
+    MBP.gestureStart = function() {
+        MBP.viewportmeta.content = 'width=device-width, minimum-scale=0.25, maximum-scale=1.6';
+    };
+
+    /**
+     * Normalized hide address bar for iOS & Android
+     * (c) Scott Jehl, scottjehl.com
+     * MIT License
+     */
+
+    // If we split this up into two functions we can reuse
+    // this function if we aren't doing full page reloads.
+
+    // If we cache this we don't need to re-calibrate everytime we call
+    // the hide url bar
+    MBP.BODY_SCROLL_TOP = false;
+
+    // So we don't redefine this function everytime we
+    // we call hideUrlBar
+    MBP.getScrollTop = function() {
+        var win = window;
+        var doc = document;
+
+        return win.pageYOffset || doc.compatMode === 'CSS1Compat' && doc.documentElement.scrollTop || doc.body.scrollTop || 0;
+    };
+
+    // It should be up to the mobile
+    MBP.hideUrlBar = function() {
+        var win = window;
+
+        // if there is a hash, or MBP.BODY_SCROLL_TOP hasn't been set yet, wait till that happens
+        if (!location.hash && MBP.BODY_SCROLL_TOP !== false) {
+            win.scrollTo( 0, MBP.BODY_SCROLL_TOP === 1 ? 0 : 1 );
+        }
+    };
+
+    MBP.hideUrlBarOnLoad = function() {
+        var win = window;
+        var doc = win.document;
+        var bodycheck;
+
+        // If there's a hash, or addEventListener is undefined, stop here
+        if ( !location.hash && win.addEventListener ) {
+
+            // scroll to 1
+            window.scrollTo( 0, 1 );
+            MBP.BODY_SCROLL_TOP = 1;
+
+            // reset to 0 on bodyready, if needed
+            bodycheck = setInterval(function() {
+                if ( doc.body ) {
+                    clearInterval( bodycheck );
+                    MBP.BODY_SCROLL_TOP = MBP.getScrollTop();
+                    MBP.hideUrlBar();
+                }
+            }, 15 );
+
+            win.addEventListener('load', function() {
+                setTimeout(function() {
+                    // at load, if user hasn't scrolled more than 20 or so...
+                    if (MBP.getScrollTop() < 20) {
+                        // reset to hide addr bar at onload
+                        MBP.hideUrlBar();
+                    }
+                }, 0);
+            });
+        }
+    };
+
+    /**
+     * Fast Buttons - read wiki below before using
+     * https://github.com/h5bp/mobile-boilerplate/wiki/JavaScript-Helper
+     */
+
+    MBP.fastButton = function(element, handler, pressedClass) {
+        this.handler = handler;
+        // styling of .pressed is defined in the project's CSS files
+        this.pressedClass = typeof pressedClass === 'undefined' ? 'pressed' : pressedClass;
+
+        if (element.length && element.length > 1) {
+            for (var singleElIdx in element) {
+                this.addClickEvent(element[singleElIdx]);
+            }
+        } else {
+            this.addClickEvent(element);
+        }
+    };
+
+    MBP.fastButton.prototype.handleEvent = function(event) {
+        event = event || window.event;
+
+        switch (event.type) {
+            case 'touchstart': this.onTouchStart(event); break;
+            case 'touchmove': this.onTouchMove(event); break;
+            case 'touchend': this.onClick(event); break;
+            case 'click': this.onClick(event); break;
+        }
+    };
+
+    MBP.fastButton.prototype.onTouchStart = function(event) {
+        var element = event.target || event.srcElement;
+        event.stopPropagation();
+        element.addEventListener('touchend', this, false);
+        document.body.addEventListener('touchmove', this, false);
+        this.startX = event.touches[0].clientX;
+        this.startY = event.touches[0].clientY;
+
+        element.className+= ' ' + this.pressedClass;
+    };
+
+    MBP.fastButton.prototype.onTouchMove = function(event) {
+        if (Math.abs(event.touches[0].clientX - this.startX) > 10 ||
+            Math.abs(event.touches[0].clientY - this.startY) > 10) {
+            this.reset(event);
+        }
+    };
+
+    MBP.fastButton.prototype.onClick = function(event) {
+        event = event || window.event;
+        var element = event.target || event.srcElement;
+        if (event.stopPropagation) {
+            event.stopPropagation();
+        }
+        this.reset(event);
+        this.handler.apply(event.currentTarget, [event]);
+        if (event.type == 'touchend') {
+            MBP.preventGhostClick(this.startX, this.startY);
+        }
+        var pattern = new RegExp(' ?' + this.pressedClass, 'gi');
+        element.className = element.className.replace(pattern, '');
+    };
+
+    MBP.fastButton.prototype.reset = function(event) {
+        var element = event.target || event.srcElement;
+        rmEvt(element, 'touchend', this, false);
+        rmEvt(document.body, 'touchmove', this, false);
+
+        var pattern = new RegExp(' ?' + this.pressedClass, 'gi');
+        element.className = element.className.replace(pattern, '');
+    };
+
+    MBP.fastButton.prototype.addClickEvent = function(element) {
+        addEvt(element, 'touchstart', this, false);
+        addEvt(element, 'click', this, false);
+    };
+
+    MBP.preventGhostClick = function(x, y) {
+        MBP.coords.push(x, y);
+        window.setTimeout(function() {
+            MBP.coords.splice(0, 2);
+        }, 2500);
+    };
+
+    MBP.ghostClickHandler = function(event) {
+        if (!MBP.hadTouchEvent && MBP.dodgyAndroid) {
+            // This is a bit of fun for Android 2.3...
+            // If you change window.location via fastButton, a click event will fire
+            // on the new page, as if the events are continuing from the previous page.
+            // We pick that event up here, but MBP.coords is empty, because it's a new page,
+            // so we don't prevent it. Here's we're assuming that click events on touch devices
+            // that occur without a preceding touchStart are to be ignored.
+            event.stopPropagation();
+            event.preventDefault();
+            return;
+        }
+        for (var i = 0, len = MBP.coords.length; i < len; i += 2) {
+            var x = MBP.coords[i];
+            var y = MBP.coords[i + 1];
+            if (Math.abs(event.clientX - x) < 25 && Math.abs(event.clientY - y) < 25) {
+                event.stopPropagation();
+                event.preventDefault();
+            }
+        }
+    };
+
+    // This bug only affects touch Android 2.3 devices, but a simple ontouchstart test creates a false positive on
+    // some Blackberry devices. https://github.com/Modernizr/Modernizr/issues/372
+    // The browser sniffing is to avoid the Blackberry case. Bah
+    MBP.dodgyAndroid = ('ontouchstart' in window) && (navigator.userAgent.indexOf('Android 2.3') != -1);
+
+    if (document.addEventListener) {
+        document.addEventListener('click', MBP.ghostClickHandler, true);
+    }
+
+    addEvt(document.documentElement, 'touchstart', function() {
+        MBP.hadTouchEvent = true;
+    }, false);
+
+    MBP.coords = [];
+
+    // fn arg can be an object or a function, thanks to handleEvent
+    // read more about the explanation at: http://www.thecssninja.com/javascript/handleevent
+    function addEvt(el, evt, fn, bubble) {
+        if ('addEventListener' in el) {
+            // BBOS6 doesn't support handleEvent, catch and polyfill
+            try {
+                el.addEventListener(evt, fn, bubble);
+            } catch(e) {
+                if (typeof fn == 'object' && fn.handleEvent) {
+                    el.addEventListener(evt, function(e){
+                        // Bind fn as this and set first arg as event object
+                        fn.handleEvent.call(fn,e);
+                    }, bubble);
+                } else {
+                    throw e;
+                }
+            }
+        } else if ('attachEvent' in el) {
+            // check if the callback is an object and contains handleEvent
+            if (typeof fn == 'object' && fn.handleEvent) {
+                el.attachEvent('on' + evt, function(){
+                    // Bind fn as this
+                    fn.handleEvent.call(fn);
+                });
+            } else {
+                el.attachEvent('on' + evt, fn);
+            }
+        }
+    }
+
+    function rmEvt(el, evt, fn, bubble) {
+        if ('removeEventListener' in el) {
+            // BBOS6 doesn't support handleEvent, catch and polyfill
+            try {
+                el.removeEventListener(evt, fn, bubble);
+            } catch(e) {
+                if (typeof fn == 'object' && fn.handleEvent) {
+                    el.removeEventListener(evt, function(e){
+                        // Bind fn as this and set first arg as event object
+                        fn.handleEvent.call(fn,e);
+                    }, bubble);
+                } else {
+                    throw e;
+                }
+            }
+        } else if ('detachEvent' in el) {
+            // check if the callback is an object and contains handleEvent
+            if (typeof fn == 'object' && fn.handleEvent) {
+                el.detachEvent("on" + evt, function() {
+                    // Bind fn as this
+                    fn.handleEvent.call(fn);
+                });
+            } else {
+                el.detachEvent('on' + evt, fn);
+            }
+        }
+    }
+
+    /**
+     * Autogrow
+     * http://googlecode.blogspot.com/2009/07/gmail-for-mobile-html5-series.html
+     */
+
+    MBP.autogrow = function(element, lh) {
+        function handler(e) {
+            var newHeight = this.scrollHeight;
+            var currentHeight = this.clientHeight;
+            if (newHeight > currentHeight) {
+                this.style.height = newHeight + 3 * textLineHeight + 'px';
+            }
+        }
+
+        var setLineHeight = (lh) ? lh : 12;
+        var textLineHeight = element.currentStyle ? element.currentStyle.lineHeight : getComputedStyle(element, null).lineHeight;
+
+        textLineHeight = (textLineHeight.indexOf('px') == -1) ? setLineHeight : parseInt(textLineHeight, 10);
+
+        element.style.overflow = 'hidden';
+        element.addEventListener ? element.addEventListener('input', handler, false) : element.attachEvent('onpropertychange', handler);
+    };
+
+    /**
+     * Enable CSS active pseudo styles in Mobile Safari
+     * http://alxgbsn.co.uk/2011/10/17/enable-css-active-pseudo-styles-in-mobile-safari/
+     */
+
+    MBP.enableActive = function() {
+        document.addEventListener('touchstart', function() {}, false);
+    };
+
+    /**
+     * Prevent default scrolling on document window
+     */
+     
+    MBP.preventScrolling = function() {
+        document.addEventListener('touchmove', function(e) {
+            if (e.target.type === 'range') { return; }
+            e.preventDefault();
+        }, false);
+    };
+
+    /**
+     * Prevent iOS from zooming onfocus
+     * https://github.com/h5bp/mobile-boilerplate/pull/108
+     * Adapted from original jQuery code here: http://nerd.vasilis.nl/prevent-ios-from-zooming-onfocus/
+     */
+
+    MBP.preventZoom = function() {
+        var formFields = document.querySelectorAll('input, select, textarea');
+        var contentString = 'width=device-width,initial-scale=1,maximum-scale=';
+        var i = 0;
+
+        for (i = 0; i < formFields.length; i++) {
+            formFields[i].onfocus = function() {
+                MBP.viewportmeta.content = contentString + '1';
+            };
+            formFields[i].onblur = function() {
+                MBP.viewportmeta.content = contentString + '10';
+            };
+        }
+    };
+
+    /**
+     * iOS Startup Image helper
+     */
+
+    MBP.startupImage = function() {
+        var portrait;
+        var landscape;
+        var pixelRatio;
+        var head;
+        var link1;
+        var link2;
+
+        pixelRatio = window.devicePixelRatio;
+        head = document.getElementsByTagName('head')[0];
+
+        if (navigator.platform === 'iPad') {
+            portrait = pixelRatio === 2 ? 'img/startup/startup-tablet-portrait-retina.png' : 'img/startup/startup-tablet-portrait.png';
+            landscape = pixelRatio === 2 ? 'img/startup/startup-tablet-landscape-retina.png' : 'img/startup/startup-tablet-landscape.png';
+
+            link1 = document.createElement('link');
+            link1.setAttribute('rel', 'apple-touch-startup-image');
+            link1.setAttribute('media', 'screen and (orientation: portrait)');
+            link1.setAttribute('href', portrait);
+            head.appendChild(link1);
+
+            link2 = document.createElement('link');
+            link2.setAttribute('rel', 'apple-touch-startup-image');
+            link2.setAttribute('media', 'screen and (orientation: landscape)');
+            link2.setAttribute('href', landscape);
+            head.appendChild(link2);
+        } else {
+            portrait = pixelRatio === 2 ? "img/startup/startup-retina.png" : "img/startup/startup.png";
+            portrait = screen.height === 568 ? "img/startup/startup-retina-4in.png" : portrait;
+            link1 = document.createElement('link');
+            link1.setAttribute('rel', 'apple-touch-startup-image');
+            link1.setAttribute('href', portrait);
+            head.appendChild(link1);
+        }
+
+        //hack to fix letterboxed full screen web apps on 4" iPhone / iPod
+        if ((navigator.platform === 'iPhone' || 'iPod') && (screen.height === 568)) {
+            if (MBP.viewportmeta) {
+                MBP.viewportmeta.content = MBP.viewportmeta.content
+                    .replace(/\bwidth\s*=\s*320\b/, 'width=320.1')
+                    .replace(/\bwidth\s*=\s*device-width\b/, '');
+            }
+        }
+    };
+
+})(document);